diff --git a/tutorials/Abiflows - results analysis.ipynb b/.backuptutorials/Abiflows - results analysis.ipynb
similarity index 100%
rename from tutorials/Abiflows - results analysis.ipynb
rename to .backuptutorials/Abiflows - results analysis.ipynb
diff --git a/tutorials/Abinit - quickstart.ipynb b/.backuptutorials/Abinit - quickstart.ipynb
similarity index 100%
rename from tutorials/Abinit - quickstart.ipynb
rename to .backuptutorials/Abinit - quickstart.ipynb
diff --git a/tutorials/Fireworks - quickstart.ipynb b/.backuptutorials/Fireworks - quickstart.ipynb
similarity index 100%
rename from tutorials/Fireworks - quickstart.ipynb
rename to .backuptutorials/Fireworks - quickstart.ipynb
diff --git a/tutorials/job.sh b/.backuptutorials/job.sh
similarity index 100%
rename from tutorials/job.sh
rename to .backuptutorials/job.sh
diff --git a/tutorials/phonon_wf.py b/.backuptutorials/phonon_wf.py
similarity index 100%
rename from tutorials/phonon_wf.py
rename to .backuptutorials/phonon_wf.py
diff --git a/tutorials/relax.py b/.backuptutorials/relax.py
similarity index 100%
rename from tutorials/relax.py
rename to .backuptutorials/relax.py
diff --git a/tutorials/part1/01_quickstart/quickstart.ipynb b/tutorials/part1/01_quickstart/quickstart.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..ada3629926a7d05d87c3c4209cdba7dae2ab4892
--- /dev/null
+++ b/tutorials/part1/01_quickstart/quickstart.ipynb
@@ -0,0 +1,177 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "northern-young",
+ "metadata": {},
+ "source": [
+ "# Five-minute quickstart\n",
+ "\n",
+ "In this quickstart, you will:\n",
+ "\n",
+ "* Add a simple workflow to the central database via the command line\n",
+ "* Run that workflow\n",
+ "* Monitor your job status with the FireWorks database\n",
+ "* Get a flavor of the Python API\n",
+ "\n",
+ "\n",
+ "## Start FireWorks\n",
+ "\n",
+ "A MongoDB database (containing the FireWorks database) is running in your docker.\n",
+ "\n",
+ "Reset/Initialize the FireWorks database (the LaunchPad) using the command line:\n",
+ "\n",
+ "```lpad reset```\n",
+ "\n",
+ "Note: All FireWorks commands come with built-in help. For example, type lpad -h or lpad reset -h. There often exist many different options for each command.\n",
+ "\n",
+ "Note2: Resetting the FireWorks removes all your workflows and jobs from your database. During this tutorial, you may use this \"often\" but when you are in production and actually using FireWorks, you will most likely almost never use this reset.\n",
+ "\n",
+ "\n",
+ "\n",
+ "## Add a Workflow\n",
+ "\n",
+ "There are many ways to add Workflows to the database, including a Python API. Let’s start with an extremely simple example that can be added via the command line:\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "amended-jimmy",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!lpad add_scripts 'echo \"hello\"' 'echo \"goodbye\"' -n hello goodbye -w test_workflow"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "necessary-potato",
+ "metadata": {},
+ "source": [
+ "This added a two-job linear workflow. The first jobs prints hello to the command line, and the second job prints goodbye. We gave names (optional) to each step as “hello” and “goodbye”. We named the workflow overall (optional) as “test_workflow”.\n",
+ "\n",
+ "Let’s look at our test workflow:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "opponent-strip",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!lpad get_wflows -n test_workflow -d more"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "deadly-gravity",
+ "metadata": {},
+ "source": [
+ "We get back basic information on our workflows. The second step “goodbye” is waiting for the first one to complete; it is not ready to run because it depends on the first job.\n",
+ "\n",
+ "\n",
+ "## Run all Workflows\n",
+ "\n",
+ "You can run jobs one at a time (“singleshot”) or all at once (“rapidfire”). Let’s run all jobs:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "destroyed-flooring",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!rlaunch rapidfire"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "pressing-spiritual",
+ "metadata": {},
+ "source": [
+ "Clearly, both steps of our workflow ran in the correct order.\n",
+ "\n",
+ "Let’s again look at our workflows:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "presidential-macintosh",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!lpad get_wflows -n test_workflow -d more"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "designing-bruce",
+ "metadata": {},
+ "source": [
+ "FireWorks automatically created launcher_ directories for each step in the Workflow and ran them. We see that both steps are complete. Note that there exist options to choose where to run jobs, as well as to tear down empty directories after running jobs.\n",
+ "\n",
+ "\n",
+ "## Look at the web GUI\n",
+ "\n",
+ "If you have a web browser, you can launch the web GUI to see your workflows using ```lpad webgui```. In this tutorial, the web GUI is directly integrated in the jupyter:\n",
+ "\n",
+ "\n",
+ "## Python code\n",
+ "\n",
+ "The following Python code achieves the same behavior:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "black-avatar",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "from fireworks import Firework, Workflow, LaunchPad, ScriptTask\n",
+ "from fireworks.core.rocket_launcher import rapidfire\n",
+ "\n",
+ "# set up the LaunchPad and reset it\n",
+ "launchpad = LaunchPad.auto_load()\n",
+ "launchpad.reset('', require_password=False)\n",
+ "\n",
+ "# create the individual FireWorks and Workflow\n",
+ "fw1 = Firework(ScriptTask.from_str('echo \"hello\"'), name=\"hello\")\n",
+ "fw2 = Firework(ScriptTask.from_str('echo \"goodbye\"'), name=\"goodbye\")\n",
+ "wf = Workflow([fw1, fw2], {fw1:fw2}, name=\"test workflow\")\n",
+ "\n",
+ "# store workflow and launch it locally\n",
+ "launchpad.add_wf(wf)\n",
+ "rapidfire(launchpad)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/part1/02_introduction_to_fireworks/fw_test.yaml b/tutorials/part1/02_introduction_to_fireworks/fw_test.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e956bf3ce1c761cc42b9c333d8640da8e7264262
--- /dev/null
+++ b/tutorials/part1/02_introduction_to_fireworks/fw_test.yaml
@@ -0,0 +1,4 @@
+spec:
+ _tasks:
+ - _fw_name: ScriptTask
+ script: echo "howdy, your job launched successfully!" >> howdy.txt
\ No newline at end of file
diff --git a/tutorials/part1/02_introduction_to_fireworks/images/single_fw.png b/tutorials/part1/02_introduction_to_fireworks/images/single_fw.png
new file mode 100644
index 0000000000000000000000000000000000000000..ecb9ee40b03dea7ac22f81c1e7f5918e8cc89a8a
Binary files /dev/null and b/tutorials/part1/02_introduction_to_fireworks/images/single_fw.png differ
diff --git a/tutorials/part1/02_introduction_to_fireworks/introduction_to_fireworks.ipynb b/tutorials/part1/02_introduction_to_fireworks/introduction_to_fireworks.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..d7d2f4efcf92f735136f193df928a74d609636f0
--- /dev/null
+++ b/tutorials/part1/02_introduction_to_fireworks/introduction_to_fireworks.ipynb
@@ -0,0 +1,429 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "political-syria",
+ "metadata": {},
+ "source": [
+ "# Introductory Tutorial\n",
+ "\n",
+ "In this tutorial, you will:\n",
+ "\n",
+ "* Add a simple workflow to the central database via a file\n",
+ "\n",
+ "* Run that workflow in a few modes\n",
+ "\n",
+ "* Get a flavor of the Python API\n",
+ "\n",
+ "The purpose of this tutorial is to get you set up as quickly as possible; it isn’t intended to demonstrate the features of FireWorks or explain things in great detail. This tutorial can be safely completed from the command line, and requires no programming.\n",
+ "\n",
+ "First, reset again the FireWorks database with ```lpad reset```.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "conceptual-subdivision",
+ "metadata": {},
+ "source": [
+ "## Add a Firework to the LaunchPad\n",
+ "\n",
+ "A Firework contains a list of computing tasks (Firetasks) to be performed. For this tutorial, we will use a Firework that consists of only a single step. We’ll tackle more complex workflows in other tutorials. Our workflow consisting of one Firework and one Firetask thus looks like this:\n",
+ "\n",
+ "\n",
+ "\n",
+ "Let's add the firework to the database of jobs:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "shared-printing",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!lpad add fw_test.yaml"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "conceptual-smart",
+ "metadata": {},
+ "source": [
+ "This command added a simple workflow to the database which was serialized into a file called fw_test.yaml. This workflow is just a single step that print some text to a file. Look inside fw_test.yaml with a text editor to see how that workflow was defined:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "elect-omega",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!cat fw_test.yaml"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "short-liberia",
+ "metadata": {},
+ "source": [
+ "You should have received confirmation that the Firework got added. You can query the database for this Firework as follows:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "packed-sound",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!lpad get_fws -i 1 -d all"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "great-divide",
+ "metadata": {},
+ "source": [
+ "This prints, in JSON format, all details of the Firework with fw_id = 1 (the first Firework entered into the database):\n",
+ "\n",
+ "Some of the Firework is straightforward, but a few sections deserve further explanation:\n",
+ "\n",
+ "The spec of the Firework contains all the information about what job to run and the parameters needed to run it.\n",
+ "\n",
+ "Within the spec, the _tasks section tells you what jobs will run. The ScriptTask is a particular type of task that runs commands through the shell. Other sections of the spec can be also be defined, but for now we’ll stick to just _tasks. Later on, we’ll describe how to run multiple _tasks or customized _tasks.\n",
+ "\n",
+ "This Firework runs the script echo \"howdy, your job launched successfully!\" >> howdy.txt\", which prints text to a file named howdy.txt.\n",
+ "\n",
+ "The state of READY means the Firework is ready to be run.\n",
+ "\n",
+ "The name is an optional field that we can set to help query for FireWorks later on. In this case, we did not specify one so a default name was used.\n",
+ "You have now stored a Firework in the LaunchPad, and it’s ready to run!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "textile-chinese",
+ "metadata": {},
+ "source": [
+ "## Launch jobs\n",
+ "\n",
+ "We can launch jobs using ```rlaunch``` (\"Rocket\" launch) command:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "committed-cardiff",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!rlaunch singleshot"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "united-banner",
+ "metadata": {},
+ "source": [
+ "This command fetches an available Firework from the FireWorks database and runs it.\n",
+ "\n",
+ "Verify that the desired task ran:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "hungry-correlation",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!cat howdy.txt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "increasing-absence",
+ "metadata": {},
+ "source": [
+ "You should see the text: \"howdy, your job launched successfully!\"\n",
+ "\n",
+ "In addition to howdy.txt, you should also see a file called FW.json. This contains a JSON representation of the Firework that the Rocket ran and can be useful later for tracking down a launch or debugging.\n",
+ "\n",
+ "Check the status of your Firework:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "interstate-glossary",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "!lpad get_fws -i 1 -d all"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "excellent-moldova",
+ "metadata": {},
+ "source": [
+ "You will now see lots of information about your Rocket launch, such as the time and directory of the launch. A lot of it is probably unclear, but you should notice that the state of the Firework is now COMPLETED.\n",
+ "\n",
+ "Try launching another rocket:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "every-setting",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "!rlaunch singleshot"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "distinguished-marble",
+ "metadata": {},
+ "source": [
+ "The message \"No FireWorks are ready to run and match query!\" indicates that it tried to fetch a Firework from the database, but none could be found. Indeed, we had previously run the only Firework that was in the database.\n",
+ "\n",
+ "## Launch many Rockets (rapidfire mode)\n",
+ "\n",
+ "If you just want to run many jobs on the central server itself, the simplest way is to run the Rocket Launcher in “rapidfire mode”. Let’s try this feature:\n",
+ "\n",
+ "Let’s add a Fireworks 3 times:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "limited-stewart",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!lpad add fw_test.yaml"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "breeding-delaware",
+ "metadata": {},
+ "source": [
+ "Confirm that the three Fireworks got added to the database, in addition to the one from before (4 total):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "exceptional-bradley",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "!lpad get_fws -d less"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "thousand-guitar",
+ "metadata": {},
+ "source": [
+ "We could also just get information for jobs that are ready to run (our 3 new FireWorks):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "packed-worse",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "!lpad get_fws -s READY -d less"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "small-murder",
+ "metadata": {},
+ "source": [
+ "Let’s launch jobs in “rapidfire” mode, which will keep repeating until we run out of Fireworks to run:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "double-contrary",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "!rlaunch rapidfire"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "stretch-knife",
+ "metadata": {},
+ "source": [
+ "You should see three directories starting with the tag launcher_. Inside each of these directories, you’ll find the results of one of your FireWorks (a file named howdy.txt):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "documentary-acrobat",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "!cat launch*/howdy.txt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "received-immune",
+ "metadata": {},
+ "source": [
+ "## Running FireWorks automatically\n",
+ "\n",
+ "We can set our Launcher to continuously look for new FireWorks to run. Let’s try this feature.\n",
+ "\n",
+ "Start the Launcher in a terminal so that it looks for new FireWorks every 10 seconds:\n",
+ "\n",
+ "```rlaunch rapidfire --nlaunches infinite --sleep 10```\n",
+ "\n",
+ "Let’s insert two FireWorks:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "generic-istanbul",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!lpad add fw_test.yaml"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "beneficial-methodology",
+ "metadata": {},
+ "source": [
+ "After a few seconds, the Rocket Launcher should have picked up the new jobs and run them. Confirm this is the case:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "square-telling",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!cat launch*/howdy.txt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "unnecessary-projector",
+ "metadata": {},
+ "source": [
+ "You should see the outputs for each Firework we inserted.\n",
+ "\n",
+ "You can continue adding FireWorks as desired; the Launcher will run them automatically and create a new directory for each job.\n",
+ "\n",
+ "As with all FireWorks scripts, you can run the built-in help for more information:\n",
+ "\n",
+ "```rlaunch -h\n",
+ "rlaunch singleshot -h\n",
+ "rlaunch rapidfire -h```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "wanted-tourist",
+ "metadata": {},
+ "source": [
+ "## What just happened?\n",
+ "\n",
+ "It’s important to understand that when you add a Firework to the LaunchPad using the lpad script, the job just sits in the database and waits. The LaunchPad does not submit jobs to a computing resource when a new Firework is added to the LaunchPad. Rather, a computing resource must request a computing task by running the Launcher.\n",
+ "\n",
+ "By running the Launcher from different locations, you can have different computing resources run your jobs. Using rapidfire mode is a convenient way of requesting multiple jobs using a single command.\n",
+ "\n",
+ "\n",
+ "## Python Examples\n",
+ "\n",
+ "While it’s possible to work operate FireWorks using YAML or JSON files, a much cleaner mode of operation is to use Python scripts. For example, here is a runnable script that creates our LaunchPad, defines our test Workflow, and runs it:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "sunrise-lecture",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from fireworks import Firework, LaunchPad, ScriptTask\n",
+ "from fireworks.core.rocket_launcher import launch_rocket\n",
+ "\n",
+ "# set up the LaunchPad and reset it\n",
+ "launchpad = LaunchPad.auto_load()\n",
+ "launchpad.reset('', require_password=False)\n",
+ "\n",
+ "# create the Firework consisting of a single task\n",
+ "firetask = ScriptTask.from_str('echo \"howdy, your job launched successfully!\"')\n",
+ "firework = Firework(firetask)\n",
+ "\n",
+ "# store workflow and launch it locally\n",
+ "launchpad.add_wf(firework)\n",
+ "launch_rocket(launchpad)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "temporal-venice",
+ "metadata": {},
+ "source": [
+ "## Summary\n",
+ "\n",
+ "At this point, you’ve successfully stored a simple job in a database and run it later on command. You even executed multiple jobs with a single command: rlaunch rapidfire, and looked for new jobs automatically using the infinite mode. This should give a basic feeling of how you can automate many jobs using FireWorks.\n",
+ "\n",
+ "However, we still haven’t covered many important topics. For example, we have not executed complex workflows (and in particular materials science workflows), run arbitrary Python code, or run jobs on different types of computing resources."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/part1/03_running_through_a_queue/job.sh b/tutorials/part1/03_running_through_a_queue/job.sh
new file mode 100644
index 0000000000000000000000000000000000000000..c42e24bb6e278872c5beb49f2a6b8f1024bc9f32
--- /dev/null
+++ b/tutorials/part1/03_running_through_a_queue/job.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+#SBATCH --partition=debug
+
+echo "I will sleep a bit"
+echo "..."
+
+sleep 10
+
+echo "Now I am ready to start"
diff --git a/tutorials/part1/03_running_through_a_queue/running_through_a_queue.ipynb b/tutorials/part1/03_running_through_a_queue/running_through_a_queue.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..4687ed6bd25d0e94e8156587065b12d2a32f5631
--- /dev/null
+++ b/tutorials/part1/03_running_through_a_queue/running_through_a_queue.ipynb
@@ -0,0 +1,191 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "twelve-medication",
+ "metadata": {},
+ "source": [
+ "# Launch Rockets through a queue\n",
+ "\n",
+ "## SLURM\n",
+ "\n",
+ "For this tutorial, SLURM has been installed and configured in the docker. You can run standard SLURM commands:\n",
+ "\n",
+ "We can submit a job to the queue, e.g. the following job.sh sleep job\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "raised-ballet",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!squeue"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bizarre-genealogy",
+ "metadata": {},
+ "source": [
+ "We can submit a job to the queue, e.g. the following job.sh sleep job:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "chief-protein",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!cat job.sh"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "sixth-murray",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!sbatch job.sh"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "naughty-anchor",
+ "metadata": {},
+ "source": [
+ "## A few explanations\n",
+ "\n",
+ "The simplest way to execute jobs through a queue would be to write a templated queue file and then submit it as a two-task Firework, as in the Firetask tutorial. However, FireWorks then considers your “job” to only be queue submission, and will consider the job completed after the queue submission is complete. FireWorks will not know when the actual payload starts running, or is finished, or if the job finishes successfully. Thus, many of the useful management and monitoring features of FireWorks will not be available to you.\n",
+ "\n",
+ "A more powerful way to execute jobs through a queue is presented in this tutorial. In this method, the queue file runs rlaunch instead of running your desired program. This method is just like typing rlaunch into a Terminal window like in the core tutorials, except that now we are submitting a queue script that does the typing for us (it’s very low-tech!). In particular, FireWorks is completely unaware that you are running through a queue!\n",
+ "\n",
+ "The jobs we will submit to the queue are basically placeholder jobs that are asleep until the job starts running. When the job is actually assigned computer resources and runs, the script “wakes” up and runs the Rocket Launcher, which then figures out what Firework to run.\n",
+ "\n",
+ "The advantage of this low-tech system is that it is quite durable; if your queue system goes down or you delete a job from the queue, there are zero repercussions. You don’t have to tell FireWorks to run those jobs somewhere else, because FireWorks never knew about your queue in the first place. In addition, if you are running on multiple machines and the queue becomes backlogged on one of them, it does not matter at all. Your submission job stuck in the queue is not preventing high-priority jobs from running on other machines.\n",
+ "\n",
+ "## Launch jobs\n",
+ "\n",
+ "This submission procedure is already configured in this tutorial and you just need to issue the ```qlaunch``` command.\n",
+ "\n",
+ "Let’s reset our database and add a new Firework:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "demographic-pitch",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!lpad add_scripts 'echo \"hello\" > hello_goodbye.txt; sleep 20; echo \"goodbye\" >> hello_goodbye.txt' -n hello"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "essential-blogger",
+ "metadata": {},
+ "source": [
+ "## Submit a job\n",
+ "\n",
+ "Use the ```qlaunch``` command to submit a job:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "double-block",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!qlaunch singleshot"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "modified-contractor",
+ "metadata": {},
+ "source": [
+ "This should have submitted a job to the queue in the current directory. You can read the log files in the logging directory, and/or check the status of your queue to ensure your job appeared.\n",
+ "\n",
+ "After your queue manager runs your job, you should see the file hello_goodbye.txt in the current directory.\n",
+ "\n",
+ "## Submitting many jobs using rapid-fire mode\n",
+ "\n",
+ "While launching a single job to a queue is nice, a more powerful use case is to submit a large number of jobs at once, or to maintain a certain number of jobs in the queue. Like the Rocket Launcher, the Queue Launcher can be run in a “rapid-fire” mode that provides these features.\n",
+ "\n",
+ "Let’s reset our database and add three new FireWorks:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "noted-globe",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!lpad add_scripts 'echo \"hello\" > hello_goodbye.txt; sleep 5; echo \"goodbye\" >> hello_goodbye.txt' -n hello"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "suitable-concentration",
+ "metadata": {},
+ "source": [
+ "Submit several jobs with a single command:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "assumed-vehicle",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "!qlaunch rapidfire -m 3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "verbal-ending",
+ "metadata": {},
+ "source": [
+ "Note: The Queue Launcher sleeps between each job submission to give time for the queue manager to ‘breathe’. It might take a few minutes to submit all the jobs.\n",
+ "\n",
+ "Note2: The command above submits jobs until you have at most 3 jobs in the queue under your username. If you had some jobs existing in the queue before running this command, you might need to increase the -m parameter.\n",
+ "\n",
+ "The rapid-fire command should have created a directory beginning with the tag block_. Navigate inside this directory, and confirm that three directories starting with the tag launch were created. The launch directories contain your individual jobs.\n",
+ "\n",
+ "There are other options to submit jobs to a queue, submitting multiple fireworks in the same queue job. See the FireWorks documentation."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/part1/04_firetasks/addition_task.py b/tutorials/part1/04_firetasks/addition_task.py
new file mode 100644
index 0000000000000000000000000000000000000000..e669b029e6c25c889ec57ef764af734bd9bd0433
--- /dev/null
+++ b/tutorials/part1/04_firetasks/addition_task.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+
+from fireworks.core.firework import FWAction, FiretaskBase
+
+__author__ = 'Anubhav Jain'
+__copyright__ = 'Copyright 2013, The Materials Project'
+__version__ = '0.1'
+__maintainer__ = 'Anubhav Jain'
+__email__ = 'ajain@lbl.gov'
+__date__ = 'Feb 17, 2013'
+
+
+class AdditionTask(FiretaskBase):
+ _fw_name = "Addition Task"
+
+ def run_task(self, fw_spec):
+ input_array = fw_spec['input_array']
+ m_sum = sum(input_array)
+
+ print("The sum of {} is: {}".format(input_array, m_sum))
+
+ return FWAction(stored_data={'sum': m_sum},
+ mod_spec=[{'_push': {'input_array': m_sum}}])
diff --git a/tutorials/part1/04_firetasks/firetasks.ipynb b/tutorials/part1/04_firetasks/firetasks.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..e7ebc32e96cdfac216c182d619e63ecfd2f980dc
--- /dev/null
+++ b/tutorials/part1/04_firetasks/firetasks.ipynb
@@ -0,0 +1,256 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "flexible-meditation",
+ "metadata": {},
+ "source": [
+ "# Defining Jobs using Firetasks\n",
+ "\n",
+ "This tutorial shows you how to:\n",
+ "\n",
+ "* Run multiple tasks within a single Firework\n",
+ "\n",
+ "* Run tasks that are defined within a Python function, rather than a shell script\n",
+ "\n",
+ "## Introduction to Firetasks\n",
+ "\n",
+ "In the Introductory tutorial, we ran a simple script that performed ```echo \"howdy, your job launched successfully!\" >> howdy.txt\"```. Looking inside fw_test.yaml, recall that the command was defined within a task labeled ScriptTask:\n",
+ "\n",
+ "```spec:\n",
+ " _tasks:\n",
+ " - _fw_name: ScriptTask\n",
+ " script: echo \"howdy, your job launched successfully!\" >> howdy.txt\n",
+ "```\n",
+ "\n",
+ "The ScriptTask is one type of Firetask, which is a predefined job template written in Python. The ScriptTask in particular refers Python code inside FireWorks that runs an arbitrary shell script that you give it. You can use the ScriptTask to run almost any job (without worrying that it’s all done within a Python layer). However, you might want to set up jobs that are more powerful than shell scripts using Python programming. Later in this section, we’ll demonstrate how to accomplish this with custom Firetasks. However, first we’ll demonstrate the simplest version to linearly run multiple tasks.\n",
+ "\n",
+ "## Running multiple Firetasks\n",
+ "\n",
+ "You can run multiple tasks within the same Firework. For example, the first step of your Firework might write an input file that the second step reads and processes. Finally, a third step might move the entire output directory somewhere else on your filesystem (or a remote server, or insert results in a database).\n",
+ "\n",
+ "Let’s create a Firework that:\n",
+ "\n",
+ "* Writes an input file based on a template with some substitutions applied. We’ll do this using a built-in TemplateWriterTask that can help create such files.\n",
+ "\n",
+ "* Executes a script using ScriptTask that reads the input file and produces some output. In our test case, it will just count the number of words in that file. However, this code could be any program, for example a chemistry code.\n",
+ "\n",
+ "* Copies all your outputs to your home directory using FileTransferTask.\n",
+ "\n",
+ "The three-step Firework thus looks like this:\n",
+ "\n",
+ "\n",
+ "\n",
+ "Let's create our three-step Firework with python:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "processed-montreal",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from fireworks import Firework, FWorker, LaunchPad, ScriptTask, TemplateWriterTask, FileTransferTask\n",
+ "from fireworks.core.rocket_launcher import launch_rocket\n",
+ "\n",
+ "# set up the LaunchPad and reset it\n",
+ "launchpad = LaunchPad.auto_load()\n",
+ "launchpad.reset('', require_password=False)\n",
+ "\n",
+ "# create the Firework consisting of multiple tasks\n",
+ "firetask1 = TemplateWriterTask({'context': {'opt1': 5.0, 'opt2': 'fast method'}, 'template_file': 'simple_template.txt', 'output_file': 'inputs.txt'})\n",
+ "firetask2 = ScriptTask.from_str('wc -w < inputs.txt > words.txt')\n",
+ "firetask3 = FileTransferTask({'files': [{'src': 'words.txt', 'dest': '~/words.txt'}], 'mode': 'copy'})\n",
+ "fw = Firework([firetask1, firetask2, firetask3])\n",
+ "\n",
+ "# store workflow and launch it locally, single shot\n",
+ "launchpad.add_wf(fw)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "published-accounting",
+ "metadata": {},
+ "source": [
+ "Let's play around in the terminal with ```lpad``` to look at what is in the database and then submit our job using ```qlaunch```.\n",
+ "\n",
+ "After having run this firework, you should see two files written out to the system, inputs.txt and words.txt, confirming that you successfully ran the first two steps of your job! You can also navigate to your home directory and look for words.txt to make sure the third step also got completed correctly."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "modern-morgan",
+ "metadata": {},
+ "source": [
+ "## Creating a custom Firetask\n",
+ "\n",
+ "The TemplateWriterTask, ScriptTask, FileTransferTask are built-into FireWorks and can be used to perform useful operations. In fact, they might be all you need! In particular, because the ScriptTask can run arbitrary shell scripts, it can in theory run any type of computation and is an ‘all-encompassing’ Firetask. ScriptTask also has many additional features (see Fireworks documentation).\n",
+ "\n",
+ "However, if you are comfortable with some basic Python, you can define your own custom Firetasks for the codes you run. A custom Firetask gives you more control over your jobs, clarifies the usage of your code, and guards against unintended behavior by restricting the commands that can be executed.\n",
+ "\n",
+ "Here, we’ll be creating a custom Firetask that adds one or more numbers using Python’s sum() function, and later building workflows using this (and similar) Firetasks.\n",
+ "\n",
+ "### How FireWorks bootstraps a job\n",
+ "\n",
+ "Before diving into an example of custom Firetask, it is worth understanding how FireWorks is bootstrapping jobs based on your specification. The basic process looks like this:\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "1. The first step of the image just shows how the spec section of the Firework is structured. There is a section that contains your Firetasks (one or many), as we saw in the previous examples. The spec also allows you to define arbitrary JSON data (labeled input in the diagram) to pass into your Firetasks as input. So far, we haven’t seen an example of this; the only information we gave in the spec in the previous examples was within the _tasks section.\n",
+ "\n",
+ "2. In the second step, FireWorks dynamically loads Python objects based on your specified _tasks. It does this by searching a list of Python packages for Python objects that have a value of _fw_name that match your setting. When we set a _fw_name of ScriptTask in the previous examples, FireWorks was loading a Python object with a _fw_name class variable set to ScriptTask (and passing the script parameter to its constructor). The ScriptTask is just one type of Firetask that’s built into FireWorks to help you run scripts easily. You can write code for custom Firetasks anywhere in the user_packages directory of FireWorks, and it will automatically be discovered. If you want to place your Firetasks in a package outside of FireWorks, please read the FireWorks configuration tutorial. You will just need to define what Python packages to search for your custom Firetasks, or use a special format that allows for direct loading of classes.\n",
+ "\n",
+ "3. In the third step, we execute the code of the Firetask we loaded. Specifically, we execute the run_task method which must be implemented for every Firetask. FireWorks passes in the entire spec to the run_task method; the run_task method can therefore modify its behavior based on any input data present in the spec, or by detecting previous or future tasks in the spec.\n",
+ "\n",
+ "4. When the Firetask is done executing, it returns a FWAction object that can modify the workflow (or continue as usual) and pass information to downstream FireWorks.\n",
+ "\n",
+ "### Custom Firetask example: Addition Task\n",
+ "\n",
+ "Let’s explore custom Firetasks with an example: a custom Python script for adding two numbers specified in the spec.\n",
+ "\n",
+ "Let’s first look at what a custom Firetask looks like in Python. Look inside the file addition_task.py which defines the Addition Task:\n",
+ "\n",
+ "```from fireworks import FiretaskBase, FWAction\n",
+ "\n",
+ "class AdditionTask(FiretaskBase):\n",
+ "\n",
+ " _fw_name = \"Addition Task\"\n",
+ "\n",
+ " def run_task(self, fw_spec):\n",
+ " input_array = fw_spec['input_array']\n",
+ " m_sum = sum(input_array)\n",
+ "\n",
+ " print(\"The sum of {} is: {}\".format(input_array, m_sum))\n",
+ "\n",
+ " return FWAction(stored_data={'sum': m_sum}, mod_spec=[{'_push': {'input_array': m_sum}}])\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "northern-edition",
+ "metadata": {},
+ "source": [
+ "A few notes about what’s going on (things will be clearer after the next step):\n",
+ "\n",
+ "* In the class definition, we are extending FiretaskBase to tell FireWorks that this is a Firetask.\n",
+ "\n",
+ "* A special parameter named _fw_name is set to Addition Task. This parameter sets what this Firetask will be called by the outside world and is used to bootstrap the object, as described in the previous section.\n",
+ "\n",
+ "* The run_task() method is a special method name that gets called when the task is run. It can take in a Firework specification (spec) in order to modify its behavior.\n",
+ "\n",
+ "* When executing run_task(), the AdditionTask we defined first reads the input_array parameter of the Firework’s spec. It then sums all the values it finds in the input_array parameter of the Firework’s spec using Python’s sum() function. Next, the Firetask prints the inputs and the sum to the standard out. Finally, the task returns a FWAction object.\n",
+ "\n",
+ "* The FWAction is giving two instructions. The first says we should store the sum we computed in the database (inside the Firework’s stored_data section). The second will pass the results on to any downstream FireTask or FireWork in the workflow as part of the spec inside a key called input_array.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "smart-leader",
+ "metadata": {},
+ "source": [
+ "Now let’s define a Firework that runs this Firetask to add the numbers 1 and 2. Look inside the file fw_adder.yaml for this new Firework definition:\n",
+ "\n",
+ "```\n",
+ "spec:\n",
+ " _tasks:\n",
+ " - _fw_name: Addition Task\n",
+ " parameters: {}\n",
+ " input_array:\n",
+ " - 1\n",
+ " - 2\n",
+ "```\n",
+ "\n",
+ "Let's add this to the Fireworks database:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "confident-messenger",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "from fireworks import Firework, FWorker, LaunchPad\n",
+ "from fireworks.core.rocket_launcher import launch_rocket\n",
+ "from fw_tutorials.firetask.addition_task import AdditionTask\n",
+ "\n",
+ "# set up the LaunchPad and reset it\n",
+ "launchpad = LaunchPad.auto_load()\n",
+ "launchpad.reset('', require_password=False)\n",
+ "\n",
+ "# create the Firework consisting of a custom \"Addition\" task\n",
+ "firework = Firework(AdditionTask(), spec={\"input_array\": [1, 2]})\n",
+ "\n",
+ "# store workflow and launch it locally\n",
+ "launchpad.add_wf(firework)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "acoustic-costume",
+ "metadata": {},
+ "source": [
+ "... and submit our job to the queue:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bizarre-gamma",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "!qlaunch singleshot"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "false-happening",
+ "metadata": {},
+ "source": [
+ "Confirm that the sum is not only printed to the screen, but also stored in our Firework in the stored_data section:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "valid-athletics",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "!lpad get_fws -i 1 -d all"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/part1/04_firetasks/fw_adder.yaml b/tutorials/part1/04_firetasks/fw_adder.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2a3d85d09178ea35db6f6770fa9a5623a0ec9c03
--- /dev/null
+++ b/tutorials/part1/04_firetasks/fw_adder.yaml
@@ -0,0 +1,7 @@
+spec:
+ _tasks:
+ - _fw_name: Addition Task
+ parameters: {}
+ input_array:
+ - 1
+ - 2
diff --git a/tutorials/part1/04_firetasks/fw_multi.yaml b/tutorials/part1/04_firetasks/fw_multi.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5f4290222d163919e35921b5dd6338569af3997d
--- /dev/null
+++ b/tutorials/part1/04_firetasks/fw_multi.yaml
@@ -0,0 +1,16 @@
+spec:
+ _tasks:
+ - _fw_name: TemplateWriterTask
+ context:
+ opt1: 5.0
+ opt2: fast method
+ output_file: inputs.txt
+ template_file: simple_template.txt
+ - _fw_name: ScriptTask
+ script: wc -w < inputs.txt > words.txt
+ use_shell: true
+ - _fw_name: FileTransferTask
+ files:
+ - dest: ~/words.txt
+ src: words.txt
+ mode: copy
diff --git a/tutorials/part1/04_firetasks/images/spec_sketch.png b/tutorials/part1/04_firetasks/images/spec_sketch.png
new file mode 100644
index 0000000000000000000000000000000000000000..02158cde496a218bd696f330edd931d6d5f86182
Binary files /dev/null and b/tutorials/part1/04_firetasks/images/spec_sketch.png differ
diff --git a/tutorials/part1/04_firetasks/images/templatetask.png b/tutorials/part1/04_firetasks/images/templatetask.png
new file mode 100644
index 0000000000000000000000000000000000000000..48b6cffca7f5951ec84ec3bbad8a2382a5e6c3ef
Binary files /dev/null and b/tutorials/part1/04_firetasks/images/templatetask.png differ
diff --git a/tutorials/part1/04_firetasks/simple_template.txt b/tutorials/part1/04_firetasks/simple_template.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4f2c10bb2b882e3d50c018609e23fbd2a76029ed
--- /dev/null
+++ b/tutorials/part1/04_firetasks/simple_template.txt
@@ -0,0 +1,2 @@
+option1 = {{opt1}}
+option2 = {{opt2}}
diff --git a/tutorials/part1/05_workflows/images/hamlet_wf.png b/tutorials/part1/05_workflows/images/hamlet_wf.png
new file mode 100644
index 0000000000000000000000000000000000000000..617428423cc7d3b642d6f412e138457f10cad279
Binary files /dev/null and b/tutorials/part1/05_workflows/images/hamlet_wf.png differ
diff --git a/tutorials/part1/05_workflows/workflows.ipynb b/tutorials/part1/05_workflows/workflows.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..3df354a905ff8c2753678e736986cb07555a71e4
--- /dev/null
+++ b/tutorials/part1/05_workflows/workflows.ipynb
@@ -0,0 +1,120 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "invalid-yellow",
+ "metadata": {},
+ "source": [
+ "# Creating Workflows\n",
+ "\n",
+ "In this tutorial, we’ll explore how to:\n",
+ "\n",
+ "* connect together multiple FireWorks into Workflows\n",
+ "\n",
+ "## The simplest workflow\n",
+ "\n",
+ "The simplest workflow consists of two jobs without any data dependency between them. The only constraint is that the second job should be executed after the first.\n",
+ "\n",
+ "For example, we might want print the first two lines of Hamlet’s soliloquy to the standard out (e.g., your Terminal window). We can represent the workflow with the following diagram:\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "Basically, we just want to ensure that “To be, or not to be,” is printed out before “that is the question:”. Let’s define and execute this workflow."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "alleged-drinking",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from fireworks import Firework, Workflow, FWorker, LaunchPad, ScriptTask\n",
+ "from fireworks.core.rocket_launcher import rapidfire\n",
+ "\n",
+ "# set up the LaunchPad and reset it\n",
+ "launchpad = LaunchPad.auto_load()\n",
+ "launchpad.reset('', require_password=False)\n",
+ "\n",
+ "# define four individual FireWorks used in the Workflow\n",
+ "task1 = ScriptTask.from_str('echo \"To be, or not to be,\"')\n",
+ "task2 = ScriptTask.from_str('echo \"that is the question:\"')\n",
+ "\n",
+ "fw1 = Firework(task1)\n",
+ "fw2 = Firework(task2)\n",
+ "\n",
+ "# assemble Workflow from FireWorks and their connections by id\n",
+ "workflow = Workflow([fw1, fw2], {fw1: [fw2]})\n",
+ "\n",
+ "# store workflow and launch it locally\n",
+ "launchpad.add_wf(workflow)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "right-access",
+ "metadata": {},
+ "source": [
+ "## A Diamond Workflow\n",
+ "\n",
+ "Let’s continue with a very similar example, but make the workflow a little more intricate. We will now print the org chart of a company. Of course, CEOs should be printed before managers, and managers before interns:\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "olive-christopher",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from fireworks import Firework, Workflow, FWorker, LaunchPad, ScriptTask\n",
+ "from fireworks.core.rocket_launcher import rapidfire\n",
+ "\n",
+ "# set up the LaunchPad and reset it\n",
+ "launchpad = LaunchPad.auto_load()\n",
+ "launchpad.reset('', require_password=False)\n",
+ "\n",
+ "# define four individual FireWorks used in the Workflow\n",
+ "task1 = ScriptTask.from_str('echo \"Ingrid is the CEO.\"')\n",
+ "task2 = ScriptTask.from_str('echo \"Jill is a manager.\"')\n",
+ "task3 = ScriptTask.from_str('echo \"Jack is a manager.\"')\n",
+ "task4 = ScriptTask.from_str('echo \"Kip is an intern.\"')\n",
+ "\n",
+ "fw1 = Firework(task1)\n",
+ "fw2 = Firework(task2)\n",
+ "fw3 = Firework(task3)\n",
+ "fw4 = Firework(task4)\n",
+ "\n",
+ "# assemble Workflow from FireWorks and their connections by id\n",
+ "workflow = Workflow([fw1, fw2, fw3, fw4], {fw1: [fw2, fw3], fw2: [fw4], fw3: [fw4]})\n",
+ "\n",
+ "# store workflow and launch it locally\n",
+ "launchpad.add_wf(workflow)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}