Basic usage
- How to run an existing protocol?
- How does it works?
- A Hello World! example.
- How to modify an existing protocol?
- Now to write a new protocol?
\todo: add a main() to each protocol
Just create an instance (python object) of the desired protocol, possibly setting some of the protocols parameters, and call the .Run() method of that object. This will create a set of files with the generated evoware scripts, human readable protocol, and comments, possibly including warnings. It may abort with more or less detailed messages about the errors.
Alternatively run GUI.py to select the protocol, the desired protocol "variant" and change some other minor parameters like number of samples or required reagents volume.
To make the actual pippeting in the real robot, open the generated .esc script in evoware. It will alert you that the check sum have not been set, which in this case just flags the fact that this is a newly generated script you have not run yet. Accept to load it in the evoware script editor. Here you will have very good assistance to visualize the details of each step and to do a normal, full TECAN validation of the correctness of the script.
Use the visual worktable map to correctly setup the labware. Use the detailed comments automatically inserted by RobotEvo in the script or the associated .protocol.txt file to fill the expected initial volume of each reagent.
Run the script as usually.
Already the creation of the protocol object will run some "boilerplate" code to setup things we need to run the useful part of our protocol.
For example it will parse the provided worktable template file (a .ewt or just a compatible .esc evoware file) and will remember (in a sort of map) all the labware present in the worktable, including its unique name, type and location.
It will also initialize some other characteristics of the used robot (not present in the worktable file) like number of tips in the LiHa, etc.
Additionally it will set the desired EvoMode: what kind of output we want to produce - normally an evoware script (which will include again all the information for the worktable), but also a human readable protocol, etc.
By running .Run() we "create" all the reagents defined there, including location in the worktable, volume, etc, making possible for the "internal iRobot" to model or track the content of each well, and to detect (and report) some potential errors in the protocol.
If at this point the protocol include a call to .cehcklist() and a GUI was previosly created a new GUI will be automatically generated to show all the details of the defined reagents making possible to change some properties without modifying programmatically the protocol. .cehcklist() will be ignored if no GUI is in use.
A typical protocol will use the high level instructions inherited from protocol_steps, like transfer, spread, with tips, etc., to express the "physical" protocol. This instructions are in turn internally implemented using lower level instructions like aspire, get tips. etc.
Each of this low level intructions will interact with the selected EvoMode to check errors and change the state of the modeled iRobot, including the volume in each well and tip, and to generate the corresponding instructions in the evoware script.
By running the script:
from EvoScriPy.protocol_steps import Protocol
import EvoScriPy.Instructions as Itr
class HelloWorld(Protocol):
name = "Hello World"
def __init__(self, GUI = None):
Protocol.__init__(self,
GUI = GUI,
output_filename = '../current/tests/hello_world',
worktable_template_filename = '../EvoScripts/wt_templates/Prefill_VEW1_ElutB_and_VEW2.ewt')
def Run(self):
self.check_list()
Itr.userPrompt("Hello World!").exec()
self.done()
if __name__ == "__main__":
HelloWorld().Run()
we will have:
