Data

Want to know what happens to your data out of sight - why it is kept in a database, how structures are indexed, how a histogram is counted? That is in The data centre. You do not need it to use anything on this page.

Data comes in two steps. You make datasets on the Data tab; you then use them on the Design tab, where a Dataset node picks one and charts draw from it. Nothing on the Design tab reads a file or reshapes data any more — if you have a design from an earlier version with a Data Joiner or Calculated Fields node, it still opens, but those nodes are dropped (the application says so once), and you make the join or the columns on the Data tab instead.

The Data tab

The Data tab is the first tab. It lists every dataset in the project’s data store with its row count and number of fields, and marks the ones that hold structures.

Click a dataset to see a Preview of its rows beneath the list, a page at a time. A dataset with more than twelve fields opens on the first twelve; press Show all N fields beside the row count to see the rest (a column you have just added is at the end), and Show first 12 to go back. A structure is shown as (structure) and a missing value as —. The ⋮ at the end of a row opens the actions for that dataset: Preview, Export CSV, Export SDF, Index structures…, Calculate fields…, Calculate molecular properties…, Filter…, Clear filter and Make filter permanent… (these two only while the dataset has a filter), Edit fields…, Add list field…, Join with… and Delete…. A dataset whose structures have been indexed carries an indexed mark beside structures; hover over it to see how. A dataset with a filter on shows how many of its rows you can see (1,245 of 35,090) and a filtered mark.

Importing a file

Import… opens a dialog listing the CSV and SDF files in the project (gzipped ones included). Choose one, give the dataset a name, and press Import. The types of the columns are worked out from every value in the file, not a sample, so a number that only shows up late in the file cannot turn a column into text half way through.

You do not have to put the file in the project first. The same dialog can upload a file from your computer (Choose file…), or import one from a URL. The server downloads that, so the address must be https:// and reachable from the internet; addresses inside a private network are refused. Either way the file is a temporary copy that is removed once the dataset is made, and nothing is added to the project’s files. A file larger than the server’s limit (2 GB unless the administrator changed it) is refused.

If the name is already taken the dialog says it replaces that dataset. A failed or cancelled import leaves the old one exactly as it was.

Importing from a service

Import from service… (next to Import…) brings data in from an online source instead of a file. It appears only when the administrator of your installation has enabled at least one source. Choose the service, fill in the form it shows, give the dataset a name and press Import; it runs as a job in the list, like a file import, and shows how many records it has fetched. If it fails or you cancel it, nothing changes: an existing dataset of that name stays as it was.

ChEMBL activities finds bioactivity measurements in ChEMBL, one row per measurement, together with the compounds they were measured on. You say what to look for:

Find activities by	You give
Target	Start typing a name (such as epidermal growth factor) and choose from the matches, which show the organism and type; or paste a ChEMBL id such as CHEMBL203
Compound list	One or more compound ids, separated by commas, spaces or new lines
ChEMBL ids in a dataset	A dataset in your project and a text field of it holding compound ChEMBL ids (any other values are ignored)
InChIKeys in a dataset	A dataset and a text field of it holding standard InChIKeys
Substructure	A SMILES string, typed or pasted, or drawn with Draw…; compounds containing it
Similarity	A SMILES string (or Draw…) and a cutoff (40 to 100 %); compounds at least that similar

For the two dataset modes, every distinct value in the field is looked up, up to 1,000. If the field has more, filter the dataset first (the Filter… action): only the rows that pass are used. The values are read when the import runs, so running it again later picks up changes to the dataset.

Minimum pChEMBL leaves out weaker or unscored measurements, and Most activities to import (10,000 unless you change it) keeps a very well studied target from filling the project. The form tells you what is wrong with an entry before you start, and Estimate asks the service roughly how many records your entries would bring in, and warns you if the limit would cut them short. Include calculated properties (on by default) adds ChEMBL’s molecular weight, AlogP, polar surface area, H-bond donors and acceptors, rotatable bonds, aromatic rings and heavy atoms to each compound; untick it if you will calculate your own.

ChEMBL makes two datasets from one import, linked: the compounds (one row each, with the structure and properties) and their activities (one row per measurement). You choose a name, and the datasets are called <name>_compounds and <name>_activities. Both are made together, and if anything goes wrong neither is changed. The compounds and the activities are linked by the compound’s ChEMBL id, and the Data tab marks them parent (compounds) and child (activities); point at the mark to see how many activities have no compound in the data (there should be none).

You can still get the one big table the old way with Join with…. The link has one rule you will notice: you cannot rename, retype or delete the field the link uses (Edit fields tells you which relation holds it). Deleting either dataset removes the link and leaves the other dataset, and the delete confirmation says so. If you re-import over one of the two, the link is checked again; if the new data cannot keep it (the ChEMBL id is missing, or repeats in the compounds), the link is removed and the job says so.

PDB ligand structures finds ligands in the Protein Data Bank like a structure you give: the same, similar to it (with a cutoff) or containing it. It makes two linked datasets. The compounds are the distinct 2D structures (no explicit hydrogens; stereoisomers are separate compounds), with the PDB ligand codes they go by and how many instances there are. The instances are each copy of one of them found in a PDB entry, one row each: the ligand as it sits in the entry (its 3D coordinates are those of the protein, so they line up in the 3D viewer), the PDB id, chain, title, method, resolution and deposit date, and a link to the entry’s structure. The link is a protein field: the structure is fetched from RCSB when the 3D viewer needs it rather than stored, and the field is not offered for charts, sorting, filtering or summaries. Most entries to import (20 by default, up to 100) matters because each entry can hold several copies of the ligand (up to 8 are taken from each), and each copy is fetched separately. Viewing the structures needs the browser to reach files.rcsb.org.

Summarise related… (on the parent’s ⋮ menu) adds columns to the compounds that summarise their activities: how many there are, or the lowest, highest, mean, sum or median of a number such as pChEMBL. Pick what to work out, the field, and a name for each new column. A compound with no activities gets 0 for a count and an empty cell for the rest. The columns are worked out when you press Add columns and are not kept up to date: if you hide rows with a filter first, only the rows still showing are counted, and running the import again replaces the compounds and loses them.

Group by…: a parent for a file that repeats a key

A file that repeats a key down its rows (a docking run with several poses of each ligand, a set of conformers, replicate assays) can be given a parent without importing anything. Open the dataset’s ⋮ menu and choose Group by…:

1. Key field — the field that repeats: text or a whole number. The dialog reads the groups and says how many there are.
2. Parent name — a new dataset, by default <dataset>_by_<key>.
3. Parent fields — the fields that are the same in every group are ticked for you (the ligand’s SMILES, say). A field that varies within a group cannot be copied.
4. Summaries — for a field that varies, such as the docking score, pick the lowest, highest or mean, and optionally a count of rows (poses per ligand).
5. Parent structure — none; drawn from a field (stored as canonical SMILES, or as a 2D molfile); or carried from the first row of each group.

The new dataset has one row per key value and is linked to the original, which is not changed. A Form on the new dataset can then list the original rows in its Related records table, and picking one drives a 3D viewer. If a filter is hiding rows, only the visible ones are grouped, and the dialog says so.

The new dataset is a snapshot. After a re-import or a change of filter, use Run grouping again… on its menu to rebuild it. Columns added to it since (by Summarise related…) are lost.

Three levels. Group the original by a finer key (a form of a compound) and then group the result by the coarser one (the compound). On the Design tab, chain two Forms: the compound’s Form lists its forms; picking one filters a second Form on the forms, whose Related records table lists its poses; picking a pose shows it in the 3D viewer.

On the Design tab, two Dataset nodes for linked datasets are joined by a dashed line from the parent to the child, labelled with the key, and each node says whether it is the parent or the child.

Selections across related datasets. In the designer, a selection in a chart on the activities can filter or mark a chart on the compounds, and the other way round: the selected rows are carried across the link to the rows that go with them. Selecting activities marks their compounds; selecting compounds marks all their activities. If the two datasets are not linked, the selection is not applied and the View tab says so.

Join along relation to… (on either dataset’s ⋮ menu) opens the Join dialog already filled in with the link’s two fields and keeping every row of the dataset you started from.

A dataset made this way is marked with the name of its source in the list; point at the mark to see the licence, when the data was fetched, which release of the source it came from, and how to cite it. Please do cite it. ChEMBL’s data is licensed CC BY-SA 3.0.

To bring it up to date, open the dataset’s ⋮ menu (on either dataset of a pair) and choose Run import again…. The form opens with the same entries; pressing Run again replaces all the datasets that import made with fresh copies. Anything you have entered in a list field on it is lost, so copy it out first if you need it.

Jobs

Importing, calculating, editing fields, filtering and joining all run as jobs. A panel beneath the list shows each one with a progress bar and what it is doing, and a large one can be cancelled part way. When a job finishes, its dataset (new, or changed in place) is up to date in the list and the Design tab sees it straight away; Dismiss clears a job from the panel. Only one job at a time runs on a dataset: starting another while one is running is refused.

Changing a dataset, and making a new one

Calculate fields…, Calculate molecular properties…, Edit fields… and Filter… change the dataset itself. It keeps its name, its rows and their ids, so every chart and Dataset node that uses it carries on, with nothing to point at something new. The columns appear when the job is done; until then the dataset is exactly as it was, and if the job fails or you cancel it, it still is. These ask for no name.

Join with… makes a new dataset, because a joined row is a combination of rows: it asks for a name (offering one such as compounds-joined), so a mistake costs nothing and you can keep every stage. Naming an existing dataset replaces it, and the dialog says so before you press the button.

Because these are made to the dataset itself, there is no copy to throw away if one was a mistake. A calculated column can’t be given the name of a field the dataset already has. A column you no longer want can be deleted with Edit fields…, which is for good; Make filter permanent… likewise deletes rows for good, and each asks before it does. If you may want to keep the original, export it first.

Export

Export CSV downloads the dataset as it is: if a filter is on, the rows it shows. Export SDF is offered for a dataset with structures and writes them back out with their properties. The file is streamed by the server, so exporting a large dataset does not load it into your browser.

Delete

Delete… removes the dataset, after asking. A saved design that draws from it shows no data in those charts until a dataset of that name exists again. Datasets made from it are separate and are not affected.

Filtering rows

Filter… hides the rows that fail your criteria. Nothing is copied or deleted: the dataset keeps its name, its rows and their ids, and every chart that uses it, the preview, an export and a join see only the rows that pass. This is not the same as selecting points on a chart, which is for exploring; a filter changes what the dataset is until you take it off. The Dataset node of a filtered dataset says how many rows it is showing.

• To change it, choose Filter… again. The dialog opens on the filter that is applied. A new filter replaces the old one and is worked out over all of the rows, so rows the old filter hid can come back.
• To remove it, choose Clear filter. Every row is shown again. Nothing was lost.
• To keep it for good, choose Make filter permanent…. This deletes the rows the filter hides, after telling you exactly how many, and cannot be undone. The dataset is then just the rows that are left and has no filter. It is refused when the filter hides nothing, or would leave no rows at all. If the dataset’s structures are indexed, the index loses the entries for the deleted molecules, except any a joined dataset made from this one still uses.

A filter is a snapshot: a row limit such as top 500 by SCORE ranks the rows at the moment you apply it, and neither it nor a condition is re-worked when you later calculate a column or change a type. Calculated columns, molecular properties and type changes are made for every row, hidden or not, so they are all there when you clear the filter. While a filter is on, the dialog’s live count is taken over a sample of the rows you can see.

Two things can narrow it, and they work together:

• Conditions — one per row, such as SCORE < -30. + Add condition adds another, and every condition must hold for a row to be kept, so building a filter up is a matter of adding rows rather than lengthening one expression. Each row is checked on its own, so a mistake is reported against the row that has it. Use or within a row for alternatives: Series == 'A' or Series == 'B'.

  Click a field name to insert it and use the operator buttons, or type. A true/false column is a test on its own — write active, or not active — or compare it with true or false: active == true, active == false. A blank counts as false, so active == false and not active both keep the rows where it is not set.

• A row limit — keep the top 500 by value of SCORE. Set both how many rows and which field to rank on; the limit takes effect once it has both. It ranks on the field’s value, not on position in the file, so it is “the best 500”, not “the first 500”. The rows come back in file order; sort a chart however you like afterwards.

Press Apply. While you type, the dialog says how many of a sample of the rows match, so you can tell a promising filter from a mistaken one before committing.

A row with no value in a field being compared is left out. SCORE < -30 skips a pose with no score — and so does not (SCORE < -30), because there is still nothing to compare. If you want the ones without a score, ask for them: isblank(SCORE). notblank(SCORE) is the opposite, and notblank(SCORE) and not (SCORE < -30) is “has a score, and it is not under −30”.

Text is compared with quotes — Series == 'A' — and contains(name, 'acid'), startswith(...) and endswith(...) match within it. Comparisons are case-sensitive.

Indexing structures

A structure is stored as text when a file is imported. That is all that drawing it needs, so a molecule grid, the 3D viewer, the interaction charts and the R-group table all work straight away, and an import of a large SDF file is quick. What text cannot do is be searched: a substructure or a similarity search has to be answered by the database, which needs the structures indexed first.

Index structures… (on a dataset that holds structures) builds that index. The dialog asks which fingerprints to build for similarity searching:

• a kind (Morgan, Feature Morgan, RDKit, Atom pair or Topological torsion),
• for the Morgan kinds a radius, and
• a length in bits (64 to 9192; 2048 is a common choice).

It starts with Morgan, radius 2, 2048 bits. You can build several, and a similarity search uses the first. Remove them all to index for substructure search only. Two fingerprints of the same kind must have the same length. Indexing runs as a job and can take a while on a large dataset. The dataset itself is not changed, and indexing again with other fingerprints replaces the index.

Until a dataset is indexed, a molecule grid built on it shows its structure-search controls greyed out, with a note saying why, and a sketch wired into it filters nothing. A Calculate fields…, Calculate molecular properties… or Edit fields… leaves the index as it is (deleting the structures field in Edit fields… is the exception: it deletes the index too), and a Filter… does not touch it either (the hidden rows are simply not searched; Make filter permanent… does remove the entries of the molecules it deletes, unless a joined dataset still uses them). A Join with… gives the new dataset the same index rather than building another, for the first dataset that has one.

About the database

About database…, at the top of the Data tab, shows how big this project’s tables are and how much of that is dead space. It is there when the project’s data lives in a database (the Data Manager’s app does; the demo gallery’s in-browser datasets do not). Everything in it is about this project only.

If your administrator has given the project a storage limit, the dialog opens with how much of it is used: a bar, the figures (Using 7.2 GB of this project’s 10 GB storage limit (72%)) and how much is free. The bar turns amber from 80% and red once the limit is reached. An import or a change that would take the project past its limit is refused before it starts, with a message saying how much it needs; nothing is half done. Once the project is at its limit, even changes that add almost nothing are refused, until you make room:

• Delete a dataset you no longer need. Its space is freed at once.
• Rows you delete (by making a filter permanent) and fields you delete free their space only after a Compact of that table.

Deleting datasets, deleting fields, making a filter permanent and Vacuum are never refused, since they are how you get back under the limit. Saving a visualisation is never refused either. With no limit, the dialog shows just the total size.

Compact has one check of its own when there is a limit. It works by writing a new copy of the table’s remaining rows before it removes the old one, so it needs that much room for a moment. If the copy would not fit in what is left of the limit, the table is not compacted and the job says so, naming the table and how much room it would need. A table whose rows have mostly been deleted needs very little room, so compacting after deleting rows still works when the project is full; it is compacting a large table of rows you are keeping that may be refused, and that would give little space back anyway. When several tables are compacted together, each is checked in turn, so the space one frees can make room for the next.

It lists every table, largest first (click a column heading to sort by it, and again to reverse): each dataset, the table behind each structure index (with the datasets that use it), and a few internal tables the service keeps for itself. For each you see:

• Size and, separately, the part of it taken by indexes.
• Rows and Dead rows. A row that has been deleted, or replaced by a newer version of itself, stays on disk as a dead row until the space is reclaimed. Dead is shown in colour once a fifth of a table is dead.
• Last vacuum: when the table was last cleaned up, by you or by the database itself.
• For a dataset with a filter on, how many rows the filter is hiding. Making the filter permanent would delete them.

The database cleans up on its own, so you rarely need to do anything. Two buttons are there for when you do:

• Vacuum makes the space of dead rows reusable and refreshes the statistics the database uses to plan queries. It runs while the table is in use, and it does not make the files smaller: the space is kept for new rows. Vacuum all does every table.
• Compact rewrites the table and its indexes into new files, which gives the disk space back. Use it after deleting a lot of rows, for example after making a filter permanent. It asks first, because it holds the table exclusively while it runs: a chart reading the table waits, and if the table is in use at that moment the job stops with a message and changes nothing. If something else is still working with older versions of the rows while it runs, it cannot remove every dead row; run it again when the project is quiet.

Both run as jobs, listed with the others, and the numbers refresh when they finish. Only one maintenance job runs at a time.

Calculating molecular properties

Calculate molecular properties… (on a dataset that holds structures) adds RDKit properties as new columns, worked out from the structure of each row. Unlike a search it does not need the structures indexed. Choose the structure field (the first is offered) and tick the properties you want. The columns are added to the dataset itself, after the ones it has, and its rows and their ids are unchanged.

Group	Properties
Size	molecular weight, exact mass, atom count, heavy atom count, heteroatom count
Lipophilicity & polarity	logP, TPSA, Labute ASA, fraction sp3 carbons
Hydrogen bonding & flexibility	H-bond donors, H-bond acceptors, rotatable bonds, amide bonds
Rings	rings, aromatic / aliphatic / saturated rings, heterocycles, aromatic / aliphatic / saturated heterocycles and carbocycles, spiro atoms, bridgehead atoms
Text	molecular formula, canonical SMILES, InChI, InChIKey, Murcko scaffold

Molecular weight, heavy atoms, logP, TPSA, H-bond donors and acceptors and rotatable bonds are ticked to start with; All and None act on a group. Each column is named with a prefix and the property, such as RDK_logp and RDK_hac. If the dataset already has a field of that name the dialog says so and the button stays disabled: change the prefix. A structure RDKit cannot read leaves its cells empty rather than stopping the job, and the dataset records how many there were. A molecule with no ring has no Murcko scaffold, which is also left empty. A dataset whose structures are indexed keeps its index.

Editing fields

Edit fields… is the one place to tidy a dataset’s columns, mainly before you draw anything from it. The dialog has a row for every field:

Column	What it does
Display name	The label shown for the field in pickers, the Dataset node, chart axes and tooltips. Leave it empty to show the field’s name, which is shown beneath it.
SQL type	What the database really calls the column (bigint, double precision, text, boolean). Read-only, and read from the database, so it is never a guess.
Type	The type the application treats it as (string, integer, float, boolean); change it with the menu.
Index	None, B-tree, Hash or BRIN. An index makes selections and searches on that field quick on a large dataset; the kinds on offer suit the field (BRIN only for numbers).
Editable	Whether people can change the field’s values. A yes/no field that is editable is a list, ticked in a card grid. Fields read from a file start read-only; a structure field never is. A text field also has a Choices box: the values people choose from, separated by commas. Clear it to remove the choices; a value a molecule already has is kept even if it is no longer a choice. A number field has Min and Max boxes instead: the range a score must lie in, or both empty for none.
🗑	Mark the field for deletion. It is struck through until you press Apply, and ↶ puts it back.

Nothing happens until Apply, and then all of it happens or none of it does: if anything fails, or you cancel the job, the dataset is exactly as it was. The dialog says what is wrong with an edit as you type it (a name that is already taken, an index that does not suit the field).

• Display names are the usual way to change how a field reads (for example RDK_logp to logP, or IC50 [nM]). A display name is a label only: charts and nodes stay bound to the field, so nothing in a design has to be redone. Characters such as brackets are ordinary text.
• Renaming the field itself (Rename field… under its display name) is for the rare case where the name really is wrong, such as a CSV file with no header line. It changes the name everywhere in the dataset, but nothing bound to the old name follows: a chart’s axis or a node in a design shows it as not found until you choose the field again. The dialog warns you. A field used by the filter that is applied cannot be renamed or deleted until the filter is cleared.
• Deleting a field removes the column and its data for good. The dialog asks once more, with the names, before it does it. Deleting the structures field also deletes the structure index, leaving a plain data table (the index is kept if another dataset, such as a join, still uses it).
• Changing a type rebuilds the column, which also drops its index; choose one again in the same edit if you want it. Structure fields can be renamed and deleted, but not retyped or indexed.
• Fields keep their place; a calculated column you added is still at the end.

Adding a list field

A list field is how you keep a list of molecules in a dataset: the ones to make, the ones ordered, the ones rejected. Add list field… in a dataset’s actions menu makes one, of one of three kinds:

• Yes/no: each molecule is on the list or not.
• Choice: each molecule has one of a set of values you give, separated by commas (make, hold, reject), or none. One choice list can stand for several yes/no lists whose answers exclude one another.
• Score: each molecule has a number within a range you give, or none: an Integer score (say 0 to 10) or a Float one (say 0 to 1). The range includes both ends.

Give it a field name (progress) and, if you like, a display name (To progress). It starts with nothing on it.

To tick molecules onto the list, add the field to a card grid’s display fields. A dataset can have as many list fields as you need, and a card grid can show several at once.

A list is an ordinary field in every other way: colour a scatter plot by it, filter on it (progress, or progress == true, keeps the rows on the list; not progress the rest), export it with the dataset. Making it read-only with Edit fields… (untick Editable) stops further changes and keeps what is on it; ticking Editable on any yes/no field makes that a list too.

A filter does not follow the list as it changes: a dataset filtered on progress keeps the rows it matched when the filter was applied, and Filter… applies it again.

Changing a type

The type of each field is worked out when a file is imported, and it decides what the field can be used for: only numeric fields are offered as axes, for instance. When the guess is wrong, choose the type you want. Each is rebuilt as a new column and replaces the old one, in the same place, only when they are all ready. A common case is a column of numbers that was read as text because one cell says NA.

A field that holds structures has no type to choose: its type is what lets the structure searches work.

A value that does not fit the new type is left missing, rather than stopping the change, and the dataset’s source line says how many there were. So NA becomes a blank in an integer column and the rest of the column becomes numbers. What fits:

To	From text	From integer	From float	From boolean
string	as it is	its digits	its text	true / false
integer	a whole number, blanks ignored	as it is	only if it is whole (3.0, not 3.5)	1 / 0
float	a decimal or exponent number (4.5, 1e3, .5)	as it is	as it is	1 / 0
boolean	true / t / false / f, any case	1 is true, 0 is false	1 is true, 0 is false	as it is

Integers beyond about 9 × 10¹⁵ (what the browser can hold exactly) are missing. Everything else about the dataset is unchanged: the same rows, with the same ids, and any structures keep their searches. A field that becomes text is treated as a category again if it has few distinct values.

Joining datasets

Join with… combines two or more datasets into one, matching rows on a key column, so a chart can draw on columns from several files at once.

Start from the primary dataset — the one you opened the menu on — and the dialog lists it first. Use + Add dataset for each further input, and for each choose the key column whose values are matched. Then choose which rows to Keep:

• Inner — only rows whose key is in every dataset.
• Left — every row of the first dataset, with matches from the others.
• Full — every row from every dataset, matched where keys agree.

A column name that two datasets share is prefixed with the name of the dataset it came from, to keep them apart. A row with no key value never matches. The joined dataset’s rows are numbered afresh, since a row is now a combination.

The join is a copy made inside the database: it does not follow later changes to its inputs, it uses only the rows each input’s filter leaves, and it shares the first structure column’s search index with its source. How a join works has the detail.

Calculating fields

Calculate fields… adds columns worked out row by row from the columns already there. They are added to the dataset itself, so every chart that uses it offers them as if they had been in the file.

Use + Add column for each one.

Click a field name to insert it, or type it; the operators + − × ÷ ^ and the functions abs, ceil, exp, floor, ln, log10, max, min, pow, round, sqrt are all there as buttons, and hovering one explains it.

Two things are worth knowing:

• Columns can build on each other, in the order listed. selectivity may refer to pIC50 if pIC50 is above it; the other way round is reported as an error, with a note to move it up.
• A value that cannot be worked out leaves that cell blank — a missing or non-numeric input, a division by zero, the log of zero or a negative. The row stays in the dataset and counts towards the chart’s missing figure. An expression that does not parse, by contrast, adds no column at all and says what is wrong: a whole column of blanks would look like a problem with your data rather than with the expression.

Note that ^ binds more tightly than a leading minus, so -2^2 is -4 — the mathematical convention, which differs from Excel’s.

The rows and their ids are unchanged, so a selection or filter wired across the dataset keeps working. You can calculate again from the columns you added, and join the dataset to others.

Dataset node

On the Design tab, a Dataset node picks one of the datasets on the Data tab. It is usually the first node you add, because every chart needs one.

Choose from the dropdown; the node then lists the fields of that dataset with the type of each — integer, float, string, or molecule for a column holding structures. Those types decide what a field can be used for: only numeric fields are offered as axes, and only a molecule field can be a structure field. With no datasets yet the dropdown says so and points you to the Data tab.

If a filter on the Data tab is hiding some of the dataset’s rows, the node says so (Filtered: 120 of 3,500 rows): every chart wired to it draws only those rows. When you change a field’s display name with Edit fields…, the node and its charts follow. When you rename or delete the field itself, a chart that used the old field has to be given a field again.

The node stores the dataset’s name, so a saved design finds its data again in a new instance as long as a dataset of that name exists there. Calculating, filtering and editing fields all change a dataset in place and keep its name, so none of them leaves a design pointing at the wrong dataset.

Output: dataset.

FileSelector

Supplies structure files — a receptor, a reference structure — to the nodes that need one. It is the only way a protein reaches the 3D viewer or either of the interaction views.

Pick from Add available file… and the entry is linked to that project file. A linked entry says so, and is re-resolved against the project each time the visualisation is loaded — which is what lets a saved visualisation work in a new instance, whose internal addresses are different. Typing a location by hand instead is allowed, but unlinks the entry.

If a linked file is no longer in the project, the node says so rather than silently doing nothing.

Output: files. A MoleculeViewer3D loads every file on the port; the two interaction views use the first as their receptor.