Setting Quality Control Flags

A key reason to track samples is to monitor their quality. In Clarity LIMS, samples are flagged with a check mark to indicate good quality (QC Pass) or an X to indicate poor quality (QC Fail).

There are many ways to determine quality, including concentration and DNA 260/280 light absorbance measurements. This example uses a tab-separated value (TSV) results file from a Thermo NanoDrop Spectrophotometer to:

Record concentration and 260/280 measurements, and;
Set quality flags in the LIMS.

In this example, once the script is installed, the user simply runs and records a step and imports the results file. The EPP / automation script does the rest of the work, by reading the file, capturing the measurements in Clarity LIMS, and setting the QC flags.

QC file formats

As spectrophotometers are used for many measurements, within many lab protocols, file formats can vary depending on the instrument software settings. Check your instruments for specific file formats and use the example below to get familiar with the QC example scripts.

User Interaction

The user selects samples and runs the QC Example step.
In the Operations Interface (LIMS v4 & earlier), the user sets the required minimum concentration and/or 260/280 lower and upper bounds.
The QC Example process creates an output artifact (shared ResultsFile) called QC Data File. This file is shown in the Sample Genealogy and Outputs panes. The "!" icon indicates that this entry is a placeholder for a file.
The users loads samples onto the spectrophotometer and follows the instrument's protocol for QC measurement.
After the measurements are complete, the user exports the TSV results file created by the spectrophotometer, using the NanoDrop software.
The user imports the TSV file into the LIMS: As Clarity LIMS parses the file, the measurements are captured and stored as output user-defined fields (UDFs). The QC Pass/Fail flags are then set on the process inputs. The flags are set according to whether they meet the concentration and/or 260/280 bounds specified in Step 2.

Example

A TSV file is created by the NanoDrop spectrophotometer. The specific file used in this example is shown below.

Default
1/6/2011  5:27 PM
Sample ID	ng/uL	A260	260/280	260/230	Constant
QCExamplePlate_A01_DNAIsolate-1	62.49	1.450	1.83	1.86	50
QCExamplePlate_A02_DNAIsolate-2	49.50	1.413	1.99	1.88	50
QCExamplePlate_A03_DNAIsolate-3	70.00	1.198	1.84	2.03	50
QCExamplePlate_A04_DNAIsolate-4	62.49	1.450	1.83	1.86	50
QCExamplePlate_A05_DNAIsolate-5	49.50	1.413	1.99	1.88	50
QCExamplePlate_A06_DNAIsolate-6	70.00	1.198	1.84	2.03	50
QCExamplePlate_A07_DNAIsolate-7	62.49	1.450	1.83	1.86	50
QCExamplePlate_A08_DNAIsolate-8	49.50	1.413	1.99	1.88	50
QCExamplePlate_A09_DNAIsolate-9	70.00	1.198	1.84	2.03	50

After the TSV file is imported and attached to the QC Example process in Clarity LIMS, a second script is automatically called with EPP. This second EPP script is part of a second process, called QC Example(file handling). The file attachment event triggers the second EPP script. You can see the process in the Sample Genealogy pane:
The example uses the TSV file Sample ID value to locate the plate and well location to which the QC flag is to be applied. In the example file shown in Step 1: The container is QCExamplePlate.
- The location A01 maps to the sample on the first well of the container named QCExamplePlate.
- The data contained in the TSV file is captured in Clarity LIMS and can be viewed on the Details tab.
Notice that the user ran only one process (QC Example), but two processes were recorded. The first EPP script created the second process, QC Example (file handling), using the REST API. Using REST to create a process is described in the Running a Process Cookbook example.
The NanoDrop QC algorithm in the script compares the concentration and the 260/280 ratio for each sample in the imported TSV file. The values are entered into the process UDFs.
- A QC Fail flag is applied:
  - If the concentration of the sample is less than specified, or;
  - If its 260/280 ratio is outside the bounds given when running the process.
- A QC Pass flag is applied when the sample has values inside the parameters provided.
- Samples with no associated values in the TSV file are unaffected. In this example, the minimum concentration is set to 60. A QC Fail flag is applied to sample-2 because its concentration level does not meet the minimum value specified.

Automation/EPP can be used to process files when they are attached to the LIMS. Using file attachment triggers is sometimes called data analysis pipelining. Basically, a series of analysis steps across a chain of processes is triggered from one file attachment.

Installation

Download the zip file to the server; on a non-production server use the gls user account.
Unzip the file to the following directory: /opt/gls/clarity/Applications. The contents of the zip file will be installed within that directory, to CookBook/NanoDropQC/.
```
unzip -d /opt/gls/clarity/Applications file-qc-2.0-bundle.zip
```
Next, unzip the config-slicer-<version>-deployment-bundle.zip in /opt/gls/clarity/Applications/CookBook/NanoDropQC/. Replace <version> with the version number of the included config-slicer.
```
cd /opt/gls/clarity/Applications/CookBook/NanoDropQC/
 
unzip config-slicer--deployment-bundle.zip
```
With Clarity LIMS running, run the following server command-line call to import the required configuration into the server (i.e., the process, sample, and fields used by the scripts):
```
java -jar config-slicer-.jar \
    -u  -p  -host  \
    -o import -k file-qc-package.xml
```

Installation validation

To confirm that the example is correctly installed, follow the steps below to simulate the recording of QC information by a user in the lab:

Start the Clarity LIMS Operations Interface client.
Create a project, and submit a 96 well plate named QCExamplePlate full of samples
Select the samples and run the QC Example process.
Click the Next and Done buttons to complete the wizard.
When the process completes, in the process summary tab's Input/Output Explorer, you'll see the shared output file placeholder (QC Data File) in the Outputs pane and in the Sample Genealogy. Right-click this placeholder and click Import.
Import the example TSV nanodrop-qc-example.tsv file provided in the zip file.
Wait for the QC flags to become visible on a subset of the samples used as inputs to the process (those located from A:1 to A:9).

Example modifications

You can modify the example script to suit your lab's QC experimental methods and calculations. For example, you may want to consider phenotypic information or extra sample data recorded in the LIMS. Two modifications to the example are described below.

Recording QC measurements on sample inputs instead of file outputs

The example script writes the measurements into user-defined fields (UDFs) associated with outputs of the process. This allows multiple measurements to be recorded for one sample, by running the process multiple times. Each time the process is run on an input sample, a new process with new output results is recorded in the LIMS.

You may instead want to write the measurements into UDFs associated with the input samples. For example, you may want to keep the data records simple: the greater the number of outputs recorded in the LIMS, the more confusing it becomes for the user to upload files and navigate results. Setting the fields on the inputs provides a single 'golden' value.

To change the configuration and script to set QC flags and field values on inputs:

Change the code in NanoDrop.groovy so that UDFs are set on inputs instead of outputs. That is, replace this line:
```
setUDF(output, <udf-name>, <value>)
```
with the following:
```
setUDF(input, <udf-name>, <value>)
```
Since you are no longer changing the outputs, you can comment or delete the line where the output is saved:
```
// Save changes
client.httpPUT(input.@uri, input)
// client.httpPUT(output.@uri, output)
```
Run the QC Example (preparation) process that was included in the configuration package you imported into your system.
The process wizard provides the option for you to either generate a new plate (container) or select a preexisting plate to hold the process outputs.
- Note: The results of this process will be placed into a plate that is different from the one in which you originally placed the samples.
Run the QC Process on the plate created in the previous step.
Edit the nanodrop-qc-example.tsv file to reflect the name of this plate (remember that the Sample ID column in the NanoDrop QC data file depends on the plate name):
- To do this, for each row, replace QCExamplePlate with the name of the plate that now holds the outputs of the process-generated plate names, for example, would be in a format similar to "27-124")
Import the modified nanodrop-qc-example.tsv into the result file placeholder generated by the QC Example process.
Wait for the QC flags to update on the inputs for which the nanodrop-qc-example.tsv file has measurements.
This time, instead of the measurements appearing in the outputs of the QC Example process, they will instead be collected as UDF values on the inputs of that process. To see these measurements, select the outputs of the parent process, QC Example (preparation), and view the output Details tab.

To ensure you are working with the latest version of an artifact, do not specify a state when retrieving artifacts via the REST API. In the example NanoDrop.groovy script provided, the stripStateQuery closure strips the state from the input and output URIs as it iterates through the input-output-map.

Using additional information stored in sample fields to set the QC flags

Most labs use multiple factors to determine sample QC flags. These factors might be associated with the submitted sample, multiple instrument measurements, or even the type of project or sample.

To demonstrate how easy it is to aggregate multiple factors into the QC flag logic, a boolean field called Human is added to the sample configuration. The script logic is modified to only set flags for human samples.

To change the configuration and script to check for human samples:

Change the code in NanoDrop.groovy (where we loop through the input/output pairs adjusting QC flags/updating UDFs), so that we first ensure we are dealing with a Human sample.

To do this, change the loop at the end of the script from this:

// all inputs we have NanoDrop results for exist, we can now assign QC status 
nanodropResults.each {
    def (input, output) = identifiedIOPairs[it.key]
 
    // Collect measurements as UDF values
    ...
    // Determine QC flags
    ...
    // Save changes
    ...
}

to this:

// All inputs we have NanoDrop results for exist, we can now assign QC status 
nanodropResults.each {
    def (input, output) = identifiedIOPairs[it.key]
 
    // Skip non-human samples
    def sample = client.httpGET(input.'sample'[0].@uri)
    def isHuman = getUDF(sample, 'Human', 'false').toBoolean()
    if (!isHuman) {
        return
    }
 
    // Collect measurements as UDF values
    ...
    // Determine QC flags
    ...
    // Save changes
    ...
}

Configure a checkbox UDF on Sample (this was done for you when you imported the configuration package provided in this application example).
Submit a new batch of samples on a 96 well plate.
Edit samples on wells from A:1 to A:3 so that the Human check box field is selected.
Run the QC Example process on all 96 samples in the plate.
In the nanodrop-qc-example.tsv file, update the Sample ID column with the correct plate name.
Import the modified nanodrop-qc-example.tsv into the result file placeholder generated by the QC Example process.
Wait for the QC flags to update on the inputs for which the NanoDrop QC data file has measurements.
Note that only the inputs A:1, A:2 and A:3 will have QC flags assigned. The other inputs, including those for which the NanoDrop QC data file has data, will be left untouched because of the selection criteria implemented.

Assumptions & notes

Clarity LIMS v1 or later (API v2 r14)
Groovy 1.7.4 or later (expected location: /opt/gls/groovy/current/)

All prerequisites are preloaded if you install on a non-production server.

Attachments

file-qc-2.0-bundle.zip:

PreviousStarting a Protocol Step via the API NextApplying Indexing Patterns to Containers Automatically

Last updated 9 months ago

Was this helpful?

Default 1/6/2011 5:27 PM Sample ID ng/uL A260 260/280 260/230 Constant QCExamplePlate_A01_DNAIsolate-1 62.49 1.450 1.83 1.86 50 QCExamplePlate_A02_DNAIsolate-2 49.50 1.413 1.99 1.88 50 QCExamplePlate_A03_DNAIsolate-3 70.00 1.198 1.84 2.03 50 QCExamplePlate_A04_DNAIsolate-4 62.49 1.450 1.83 1.86 50 QCExamplePlate_A05_DNAIsolate-5 49.50 1.413 1.99 1.88 50 QCExamplePlate_A06_DNAIsolate-6 70.00 1.198 1.84 2.03 50 QCExamplePlate_A07_DNAIsolate-7 62.49 1.450 1.83 1.86 50 QCExamplePlate_A08_DNAIsolate-8 49.50 1.413 1.99 1.88 50 QCExamplePlate_A09_DNAIsolate-9 70.00 1.198 1.84 2.03 50

// all inputs we have NanoDrop results for exist, we can now assign QC status nanodropResults.each { def (input, output) = identifiedIOPairs[it.key] // Collect measurements as UDF values ... // Determine QC flags ... // Save changes ... }

// All inputs we have NanoDrop results for exist, we can now assign QC status nanodropResults.each { def (input, output) = identifiedIOPairs[it.key] // Skip non-human samples def sample = client.httpGET(input.'sample'[0].@uri) def isHuman = getUDF(sample, 'Human', 'false').toBoolean() if (!isHuman) { return } // Collect measurements as UDF values ... // Determine QC flags ... // Save changes ... }