Is it possible to make Cellario methods that are composable? I can explain further if I get hits on this post.

Are you asking if you can generate a protocol on the fly outside of cellario itself and run it?

I’m also not sure what you mean by “composable”, but Cellario can utilize run-time variables and can incorporate custom scripted steps. I have a lot of experience with Cellario, so I can probably help with more explanation.

So you can imagine that any order you make would involve loading up tips to a liquid handler deck. Since the arms can’t reach all available spots (usually just the back two rows) it would be nice to do this because then I can maximize deck space.

I’ve heard of labs “loading up the deck with tip boxes Cellario doesn’t know about” which seems odd to me.

So I’d make a Cellario order called Load Tips. It would take an input what liquid handler and what tips. It’s easy to keep a micro serve stacked and loaded with tip boxes. There can be another program on the liquid handler that handles the redistribution of tip boxes once the precise arm is done.

I could make a reverse of this to do at the end to discard tip boxes.

I’m told I can’t do this though and that a plate (or tip box) can’t end inside a liquid handler.

By composable I mean that if I can make small units of work in Cellario, I build up more complex work and reuse old work.

You’re right that Cellario will not let you end an order with the tips left on the liquid handler. There is a feature that lets you save a “subroutine”, basically a series of steps from a protocol that can be easily dragged into a new protocol. I think this is limited to steps that pertain to a single thread, though. So if you tried to make a subroutine that included a liquid transfer step that connected two or more threads, it would not work.

For your use-case, though, I think a subroutine might one way to do this. If you have more than just the move step to get the tips from storage to the liquid handler you can set those steps up as a subroutine, and then drag that subroutine into new protocols. I have not used subroutines extensively because of the limitation on the steps only relating to a single thread.

If you create a method on your liquid handler that just moves tips that are delivered by the robot arm, you can call it through the liquid transfer step in Cellario and just have it associated with one thread.

I think the harder part is going to be getting Cellario to unload a large number of tips without also unloading a bunch of source and destination labware. For this using merge (and maybe loop) steps will be key. Merge basically holds up execution of all of the connected threads until they are all at that step, so putting the “load up the liquid handler” steps before a merge that links to the plate threads before any other steps will ensure that all that work happens before the other plates are unloaded.

I think you should be able to do all of this without writing any custom scripts, but a basic script that modifies a merge “Times Used” parameter to equal the total number of plates in the tips thread might be necessary to get them all to move onto the liquid handler before the rest of the protocol moves forward.

Pinging this thread again to ask a similar question to @smohler, is it possible to generate a protocol within Cellario and allocate the resources/labware needed for it? Lets say I have a worklist that, at run start, requires an unknown number/type of labware. I have a C# parser already that can digest this worklist and pass off the required information to a liquid handler as parameters.

However, Cellario doesn’t know about this labware and won’t load it onto the liquid handler, nor do I know which spots are free on the liquid handler to place this labware. I’m aware there’s a Cellario Scripting API method that is supposed to return all available locations in a resource, though in my testing this always returns a null object.

Ideally, I’d be able to spawn plates within a script as the worklist requires, given a reasonable assumption of plate availability and storage positions. Otherwise it’d be acceptable to set up plates in Cellario and then have this script move the plates around as needed, though I’m not sure how to do so. Any help is much appreciated.

@DCurrier Thanks for your answer on 9/21, very informative. I had the same question as OP. Can you please elaborate a bit on what you mean by “thread” in your reply?

Can these subroutines be combined to create new workflows? For example could one take Subroutine A and add Subroutine B to create Subroutine AB?

@Kyle Sorry for the lag time in my reply. I’ve been out of office a bit lately.

In Cellario terms, a thread is usually a type of labware. When designing a protocol a thread is added for a specific labware type and the steps are added to the thread. Threads can be linked by certain steps, like liquid transfers.

I am not very well-versed in using subroutines since most of the work I want to do involves liquid transfers which are not compatible with subroutines. As I understand it though, a subroutine is just a collection of steps. If you have two collections, you could place them in sequence. I don’t think there is a limit to how many subroutines you can store or add to a protocol.

Protocols are fixed, though, and once you run them they cannot be changed. I’m not sure if you were asking about dynamically assembling subroutines at the time of a run or just manually assembling them to form a protocol, but the later is more how they were designed to be used, I think.

Cellario 3.5 and 4.0 have some big improvements to the control of liquid handler decks. It now has the ability to start and end labware on the deck, as well as handle on deck waste and sequenced loading and unloading. Device Driver updates also provide more control over transferring labware in and out of the deck. For example you can define a unique method to be executed, by the liquid handler, per nest when Cellario is loading or unloading a labware. This can give you more flexibility over how you load and unload a deck.

1 Like

I believe the functionality you are describing exists within Cellario Order Broker. This is a piece of software from HRB that is able to generate Cellario orders from template protocols with unknown type and number of labware. It will also interface with your LIMS for further integration and data management.

It may be possible to setup your workflow just using the Scripting API, but I would also encourage looking into Cellario Services API and Cellario Order Broker as these expose more tools for creating and managing Cellario orders than the Scripting API does.