# Quick visualization

Story: “I have data right now and I want to see it right now. I’m not worried about organizing it yet.”

This page is for data that isn’t well organized yet but is still worth sending to Nominal for visualization and long-term storage. It takes the fewest steps to [upload](https://dev.nominal.io/platform/reference/glossary.md#upload "To send a finished file to Nominal, from the app or a client library, so it can be ingested into a dataset.") your data and see it, fast.

Quick visualization only needs the [dataset](https://dev.nominal.io/platform/reference/glossary.md#dataset "A store in Nominal for time-series and log data, which grows as you upload or stream more into it.") portion of the data model. A [dataset](https://dev.nominal.io/platform/data-model.md#data-model-time-series) contains a set of named [channels](https://dev.nominal.io/platform/reference/glossary.md#channel "A named signal: a series of measurements or computed values, such as voltage, pressure, or system state."). Each [channel](https://dev.nominal.io/platform/data-model.md#data-model-channels) has a collection of (time, value) points.

## Uploading data

In the Nominal app, upload a natively supported file (such as CSV), or a file type with an [extractor](https://dev.nominal.io/platform/reference/glossary.md#extractor "Your own parsing code, packaged as a Docker image, that Nominal runs during ingest to convert a file it can't read natively into time-series data."), and have the upload create a [run](https://dev.nominal.io/platform/reference/glossary.md#run "A named, time-bounded period of interest on one or more assets, such as a test, a flight, or a race session."). You plot data in a [workbook](https://dev.nominal.io/platform/reference/glossary.md#workbook "Where you analyze time-series data from assets and runs, in tabs and panels, after a test or live."), which can open on a run, so creating the run during upload gets you to a plot without setting anything else up. If you don’t have a file of your own, use [`sample.csv`](https://dev.nominal.io/platform/_downloads/e9d8e9ebac8564f38a3a974dd7167539/sample.csv), a minute of test data.

1. In the sidebar, click **+** (**New**), then **Upload data**. Drop your files onto **Upload files**, or click **SELECT FILES** and locate your data on disk.
2. Click **SELECT A DESTINATION** and choose **Standalone dataset**. Pick a dataset, or click **NEW DATASET** to make one. For a new dataset, enter at least a name and select **CREATE DATASET**.
   ![The Select a destination step, with Standalone dataset as the last option](https://dev.nominal.io/platform/_images/upload-destination.png)
3. For a natively supported file, in the **Settings** panel, check the **Timestamp column** and **Timestamp format** against your data file and adjust to match. For a file type with an extractor, see [Run an ingest: Web UI](https://dev.nominal.io/extractors/ingest.md#web-ui).
4. Turn on **Create run**, name the run, and click **CREATE RUN**.
5. Click **CONFIRM & INGEST**, then **VIEW RUN**.
6. Continue with [visualizing data](https://dev.nominal.io/platform/data-model/paradigms/stories/data-fast.md#visualizing-data).

## Using client tools

Application developers can get *live* data into Nominal using one of the available client libraries, engineering tools such as [NI TestStand](https://dev.nominal.io/ni-teststand.md) or [Simulink](https://dev.nominal.io/simulink.md), or hardware integration libraries like [Instro](https://instro.nominal.io/).

To get started programmatically, first use the Nominal app or your tool to create a dataset and get its [RID](https://dev.nominal.io/platform/reference/glossary.md#rid "Short for resource identifier: a unique ID for any item in Nominal."), which has the form `<ri.catalog.instance.dataset.identifier>`.

To create a dataset and get its RID in the Nominal app:

1. In the sidebar, click **+** (**New**), then **Upload data**.
2. On the **Stream data** card, click **SET UP**.
3. Choose **Standalone dataset [Advanced]**. Pick a dataset, or click **NEW DATASET**, enter a name, and select **CREATE DATASET**.
4. The **Start streaming** step shows the **Dataset RID**. Copy it, then click **DONE**.
   ![The Start streaming step, with the Dataset RID and its copy button, and DONE at the bottom right](https://dev.nominal.io/platform/_images/start-streaming.png)

Once you have the RID, each tool allows you to enter the RID to [stream](https://dev.nominal.io/platform/reference/glossary.md#stream "To send points to Nominal as they're produced, instead of uploading a finished file.") to:

**Python**

```python
from datetime import datetime, timezone
from nominal.core import NominalClient

client = NominalClient.from_profile("default")

dataset_rid = "<ri.catalog.instance.dataset.identifier>"
dataset = client.get_dataset(dataset_rid)  # or client.create_dataset("My dataset")

# A run with no end stays open, so its workbook can go live
run = client.create_run("Quick look", start=datetime.now(timezone.utc), end=None)
run.add_dataset("default", dataset)  # "default" is the ref name

with dataset.get_write_stream() as stream:
    stream.enqueue("voltage", datetime.now(timezone.utc), 12.1)
```

**Instro**

```python
# Start the simulator first, in another terminal: python -m instro.dmm.scpi_sim_server
from instro.dmm import InstroDMM
from instro.dmm.drivers import SimulatedDMM  # or Agilent34401A, Keysight34461A, Keithley2400
from instro.lib.publishers import NominalCorePublisher

dataset_rid = "<ri.catalog.instance.dataset.identifier>"

dmm = InstroDMM(
    name="dmm",
    driver=SimulatedDMM("TCPIP0::127.0.0.1::5026::SOCKET"),
    publishers=[NominalCorePublisher(dataset_rid=dataset_rid)],
)
with dmm:
    dmm.read_dc_voltage()  # published to the dataset
```

**MATLAB**

```matlab
dataset_rid = "<ri.catalog.instance.dataset.identifier>";

client = nominal.Client.fromProfile();
dataset = client.datasetByRid(dataset_rid);

% A run starts on an asset; with no end it stays open, so its workbook can go live
asset = client.getOrCreateAsset("My asset");
asset.addDataset(dataset);
r = asset.run("Quick look");

stream = dataset.stream();
voltage = stream.channel("voltage");
voltage.push(datetime("now", TimeZone="UTC"), 12.1);
```

**LabVIEW**

![LabVIEW example that streams to a Nominal dataset](https://dev.nominal.io/platform/_images/labview-quick-visualization.png)

[`Download the example VI`](https://dev.nominal.io/platform/_downloads/6391d5847e6589f0da074f0b9c7c87d0/labview-quick-visualization.vi)

**Rust**

```rust
use nominal::core::RunCreate;
use nominal::streaming::prelude::*;
use nominal::streaming::stream::NominalDatasetStreamBuilder;

let client = nominal::NominalClient::from_profile("default")?;
let dataset_rid = "<ri.catalog.instance.dataset.identifier>";
// or create one: client.catalog().create_dataset(DatasetCreate::new("My dataset")).await?.rid()

// A run with no end stays open, so its workbook can go live
let run = client.runs().create(RunCreate::new("Quick look", chrono::Utc::now())).await?;
client.runs().add_dataset(run.rid(), "default", dataset_rid).await?; // "default" is the ref name

// token: your API key, as a BearerToken
let stream = NominalDatasetStreamBuilder::new()
    .stream_to_core(token, ResourceIdentifier::new(dataset_rid)?, tokio::runtime::Handle::current())
    .build();
stream.double_writer(ChannelDescriptor::new("voltage")).push(chrono::Utc::now(), 12.1);
```

**Simulink**

This is the example model from the Nominal Blockset’s Getting Started page. Open it in MATLAB with:

```matlab
open_system(fullfile(nominal_root, 'examples', 'nominal_stream_example.slx'))
```

![Simulink model that streams three signals to a Nominal dataset](https://dev.nominal.io/platform/_images/simulink-quick-visualization.png)

The Python, MATLAB, and Rust examples above also create a [run](https://dev.nominal.io/platform/reference/glossary.md#run "A named, time-bounded period of interest on one or more assets, such as a test, a flight, or a race session."). If your code only writes to a dataset, plot it with a [quick plot](https://dev.nominal.io/platform/data-model/paradigms/stories/data-fast.md#from-a-dataset). Either way, continue with [visualizing data](https://dev.nominal.io/platform/data-model/paradigms/stories/data-fast.md#visualizing-data).

## Visualizing data

Both paths above end with a dataset, and many also create a run. A quick plot shows the dataset’s channels without a run or a [workbook](https://dev.nominal.io/platform/reference/glossary.md#workbook "Where you analyze time-series data from assets and runs, in tabs and panels, after a test or live."), which is enough to check that each channel is getting data and has the name you expect. For analysis in tabs and [panels](https://dev.nominal.io/platform/reference/glossary.md#panel "A block in a workbook where you plot, compare, or annotate time-series data, such as a chart, scatter plot, histogram, or map."), open a workbook on the run.

### From a dataset

1. On the run’s page, click the **Data sources** tab, or **Assets** for a run on an [asset](https://dev.nominal.io/platform/reference/glossary.md#asset "A physical or simulated device or system you track in Nominal, such as a vehicle, a component, a unit under test, or a test stand.") you created, then the arrow beside your dataset. Without a run, in the sidebar, click **Data**, then **Data sources**, and open your dataset.
   ![A run's Data sources tab, with the arrow beside its dataset highlighted](https://dev.nominal.io/platform/_images/run-data-sources-tab.png)
2. Click **QUICK PLOT**.
   ![A dataset's page with its Channels tab, and QUICK PLOT at the top right](https://dev.nominal.io/platform/_images/dataset-quick-plot.png)
3. Check the channels to plot. Each one gets its own chart.
   ![The Quick plot window, with two channels checked and each on its own chart](https://dev.nominal.io/platform/_images/quick-plot.png)

### From a run

1. On the run’s page, click **NEW WORKBOOK**.
2. Under **CHANNELS**, find your channels and drag them onto the canvas to create a time series chart.

![A run's page, with New workbook at the top right](https://dev.nominal.io/platform/_images/run-new-workbook.png)

To follow [streamed](https://dev.nominal.io/platform/reference/glossary.md#stream "To send points to Nominal as they're produced, instead of uploading a finished file.") data as new points arrive:

1. In the bottom bar, click **GO LIVE**. The button reads **LIVE** while the workbook streams. Click it again to stop.
2. Choose a [time window](https://dev.nominal.io/platform/reference/glossary.md#time-window "The time range currently shown in a workbook. It controls what data Nominal loads and updates when you zoom or pan.") from the dropdown beside it. The default is the last 30 seconds.

![The live window menu, set to the last 30 seconds](https://dev.nominal.io/platform/_images/live-window.png)

**GO LIVE** isn’t available if the workbook has [time offsets](https://dev.nominal.io/platform/reference/glossary.md#offset "A time shift applied to data without changing its stored timestamps."), if all of its runs have ended, or if its [data source](https://dev.nominal.io/platform/reference/glossary.md#data-source "Anything an asset or run reads time-series data from: a dataset, a connection to an external database, or a video.") can’t stream, such as an external database [connection](https://dev.nominal.io/platform/reference/glossary.md#connection-nominal-data-source "A data source that links to an external time-series database, so Nominal can read data from outside systems.").

## Where to go next

Docs by Connector

[site:/index.html#by-language](https://dev.nominal.io/index.md#by-language)

Nominal Fundamentals

[Data model core concepts](https://dev.nominal.io/platform/data-model.md)

Examples

[site:/quickstart/quick/](https://dev.nominal.io/quickstart/quick.md)