# ProjectDict
```c++
simple
{
	// execute always;

	// Change files in during execution.
	changes
	{
		// This is the automatic reduction of a case. It will look for
		// caseSetupDict (or, if the case lacks it, controlDict) and will
		// change the endTime to 10x the deltaT.
		reduce
		{
			steps 10;
		}
	}

	// List of commands to be run.
	commands
	(
		"helyxHexMesh"
		"helyxSolve"
	);

	// If all commands run without failing, run this:
	post
	(
		(
			// compare is a special command, which will trigger calling
			// helyxProject-compare-[name], passing the other parameters
			// to the command; it also expects it to produce some foam
			// file with the comparison results (format described later)
			compare tsv;
			files "postProcessing/foo" "reference/foo";
			variables "phi";
			absolute 1e-10;
		)
	)
}

continuation
{
	// This run will only be executed if the run named "simple" passes.
	execute simple pass;
	// Reuse the workspace; if not defined, a new workspace will be created,
	// start the run from scratch. With "reuse", the commands will be run in
	// the previous run workspace -- in this case, whatever was left from the
	// "simple" run will also be present here.
	workspace reuse;
	changes 
	{
		// "continue" defines a continuation. It also changes caseSetupDict
		// (or controlDict) to have 1xdeltaT, but also change "startTime" to
		// "lastTime"
		continue
		{
			steps 1;
		}
	}

	// This run will execute only one command.
	commands
	(
		"helyxSolve"
	)

	post
	(
		(
			compare tsv;
			files "postProcessing/foo" "reference/restart/foo";
			variables "phi";
			absolute 1e-10;
		)
	)
}

split
{
	execute simple fail;
	// It is possible to indicate that the commands will come from one
	// external file -- in this case, a shell script named "Allrun"
	// (this replicates the way helyxVerify works).
	commands from "Allrun";
	workspace reuse;

	post
	(
		(
			compare tsv;
			files "postProcessing/foo" "$SIMPLE_RUN/postProcessing/foo";
			variables "phi";
		)
	)
}

more-continuation
{
	// This is the second run set to run after "simple" passes. The ordering
	// is given by their appearance in the file: "continuation" will be run
	// before "more-continuation"
	execute pass simple;
	workspace reuse;

	changes
	{
		// instead letting Project do all the changes, we'll do it manually.
		files {
			"system/caseSetupDict"
			{
				global
				{
					system
					{
						controlDict
						{
							startTime latestTime;
							endTime 0.6;
						}
					}
				}
			}
		}
	}
}

variation
{
	// This have no execution clause, so it will be run in parallel with 
	// "simple" (being considering a different case, for example).

	// Change files in during execution.
	changes
	{
		// it is possible to mix specialized changes with manual ones, but
		// specialized changes will always run before the manual changes.
		// this makes the manual more explicit than the specialized.
		reduce
		{
			steps 5;
		}
		files {
			"system/caseSetupDict"
			{
				regions
				{
					".*"
					{
						materialProperties {
							
						}
					}
				}
			}
		}
	}
	
	commands
	(
		"helyxHexMesh"
		"helyxSolve"
	);

	post
	(
		(
			compare tsv;
			files "postProcessing/foo" "reference/foo";
			variables "phi";
			absolute 1e-10;
		)
	)
}
```