@datagrok/bio 2.8.6 → 2.10.0

package/src/substructure-search/substructure-search.ts

@@ -17,64 +17,93 @@ export const enum MONOMERIC_COL_TAGS {
 
 const SUBSTR_HELM_COL_NAME = 'substr_helm';
 
-/**
- * Searches substructure in each row of Macromolecule column
- *
- * @param {DG.column} col Column with 'Macromolecule' semantic type
- */
-export function substructureSearchDialog(col: DG.Column<string>): void {
-  const units = col.getTag(DG.TAGS.UNITS);
-  const separator = col.getTag(bioTAGS.separator);
-  // const notations = [NOTATION.FASTA, NOTATION.SEPARATOR, NOTATION.HELM];
-
-  const substructureInput = ui.textInput('Substructure', '');
-
-  const editHelmLink = ui.link('Edit helm', async () => {
-    updateDivInnerHTML(inputsDiv, grid.root);
-    await ui.tools.waitForElementInDom(grid.root);
-    setTimeout(() => {
-      grid.cell(SUBSTR_HELM_COL_NAME, 0).element.children[0].dispatchEvent(
-        new KeyboardEvent('keydown', {key: 'Enter'}));
-    }, 100);
-  });
+export class SubstructureSearchDialog {
+  units: string;
+  separator: string;
+  inputsDiv: HTMLDivElement;
+  substructureInput: DG.InputBase<string>;
+  separatorInput: DG.InputBase<string>;
+  editHelmLink: HTMLAnchorElement;
+  columnsInput: DG.InputBase<DG.Column | null>;
+  grid: DG.Grid;
+  col: DG.Column;
+  dialog: DG.Dialog;
+
+  constructor(columns: DG.Column<string>[]) {
+    this.col = columns[0];
+    this.createUI();
+  }
+
+  editHelmLinkAction(): void {
+    updateDivInnerHTML(this.inputsDiv, this.grid.root);
+    ui.tools.waitForElementInDom(this.grid.root).then(() => {
+      setTimeout(() => {
+        this.grid.cell(SUBSTR_HELM_COL_NAME, 0).element.children[0].dispatchEvent(
+          new KeyboardEvent('keydown', {key: 'Enter'})
+        );
+      }, 100);
+    });
+  }
+
+  updateInputs(): void {
+    const selectedInput = this.units === NOTATION.HELM ? ui.divV([this.columnsInput, this.editHelmLink]) :
+      this.units === NOTATION.SEPARATOR ? ui.inputs([this.columnsInput, this.substructureInput, this.separatorInput]) :
+        ui.inputs([this.columnsInput, this.substructureInput]);
 
-  const df = DG.DataFrame.create(1);
-  df.columns.addNewString(SUBSTR_HELM_COL_NAME).init((_i) => '');
-  df.col(SUBSTR_HELM_COL_NAME)!.semType = col.semType;
-  df.col(SUBSTR_HELM_COL_NAME)!.setTag(DG.TAGS.UNITS, NOTATION.HELM);
-  const grid = df.plot.grid();
-  const separatorInput = ui.textInput('Separator', separator);
-
-  const inputsDiv = ui.div();
-
-  const inputs = units === NOTATION.HELM ? ui.divV([editHelmLink]) :
-    units === NOTATION.SEPARATOR ? ui.inputs([substructureInput, separatorInput]) :
-      ui.inputs([substructureInput]);
-
-  updateDivInnerHTML(inputsDiv, inputs);
-
-  ui.dialog('Substructure Search')
-    .add(ui.divV([
-      ui.divText(`Notation: ${units}`),
-      inputsDiv,
-    ]))
-    .onOK(async () => {
-      let substructure = units === NOTATION.HELM ? df.get(SUBSTR_HELM_COL_NAME, 0) : substructureInput.value;
-      if (units === NOTATION.SEPARATOR && separatorInput.value !== separator && separatorInput.value !== '')
-        substructure = substructure.replaceAll(separatorInput.value, separator);
-      const matchesColName = `Matches: ${substructure}`;
-      const colExists = col.dataFrame.columns.names()
-        .filter((it) => it.toLocaleLowerCase() === matchesColName.toLocaleLowerCase()).length > 0;
-      if (!colExists) {
+    updateDivInnerHTML(this.inputsDiv, selectedInput);
+  }
+
+  updateNotationDiv(): void {
+    this.units = this.col.getTag(DG.TAGS.UNITS);
+    this.separator = this.col.getTag(bioTAGS.separator);
+    const notationDiv = this.dialog.root.getElementsByClassName('notation-text')[0];
+    if (notationDiv)
+      notationDiv.textContent = `Notation: ${this.units}`;
+  }
+
+  createUI(): void {
+    const dataframe = grok.shell.tv.dataFrame;
+    const seqColOptions = {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE};
+    this.columnsInput = ui.columnInput('Column', dataframe, this.col, (column: DG.Column) => {
+      this.col = column;
+      this.updateNotationDiv();
+      this.updateInputs();
+    }, seqColOptions);
+
+    this.substructureInput = ui.stringInput('Substructure', '');
+
+    this.editHelmLink = ui.link('Edit helm', () => this.editHelmLinkAction(), undefined, {style: {position: 'relative', left: '95px'}});
+
+    const df = DG.DataFrame.create(1);
+    df.columns.addNewString(SUBSTR_HELM_COL_NAME).init((_i) => '');
+    df.col(SUBSTR_HELM_COL_NAME)!.semType = this.col.semType;
+    df.col(SUBSTR_HELM_COL_NAME)!.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+    this.grid = df.plot.grid();
+    this.separatorInput = ui.stringInput('Separator', this.separator);
+
+    this.inputsDiv = ui.div();
+    this.units = this.col.getTag(DG.TAGS.UNITS);
+    this.separator = this.col.getTag(bioTAGS.separator);
+    this.updateInputs();
+
+    this.dialog = ui.dialog('Substructure Search')
+      .add(ui.divV([
+        ui.divText(`Notation: ${this.units}`, 'notation-text'),
+        this.inputsDiv,
+      ]))
+      .onOK(async () => {
+        let substructure = this.units === NOTATION.HELM ? df.get(SUBSTR_HELM_COL_NAME, 0) : this.substructureInput.value;
+        if (this.units === NOTATION.SEPARATOR && this.separatorInput.value !== this.separator && this.separatorInput.value !== '')
+          substructure = substructure.replaceAll(this.separatorInput.value, this.separator);
         let matches: DG.BitSet;
-        if (units === NOTATION.HELM)
-          matches = await helmSubstructureSearch(substructure, col);
+        if (this.units === NOTATION.HELM)
+          matches = await helmSubstructureSearch(substructure, this.col);
         else
-          matches = linearSubstructureSearch(substructure, col);
-        col.dataFrame.columns.add(DG.Column.fromBitSet(matchesColName, matches));
-      } else { grok.shell.warning(`Search ${substructure} is already performed`); }
-    })
-    .show();
+          matches = linearSubstructureSearch(substructure, this.col);
+        this.col.dataFrame.filter.and(matches);
+      })
+      .show();
+  }
 }
 
 export function linearSubstructureSearch(substructure: string, col: DG.Column<string>, separator?: string): DG.BitSet {

package/src/tests/activity-cliffs-tests.ts

@@ -47,5 +47,5 @@ category('activityCliffs', async () => {
     viewList.push(actCliffsTableViewWithEmptyRows);
 
     await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 3, DimReductionMethods.UMAP, 'sequence');
-  });
+  }, {skipReason: 'GROK-13851: Unhandled exceptions'});
 });

package/src/tests/converters-test.ts

@@ -5,7 +5,6 @@ import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src
 
 import {ConverterFunc} from './types';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 // import {mmSemType} from '../const';
@@ -134,8 +133,8 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$$`,
       throw new Error(`Argument 'separator' is mandatory for target notation '${tgtNotation.toString()}'.`);
 
     return function(srcCol: DG.Column): DG.Column {
-      const converter = new NotationConverter(srcCol);
-      const resCol = converter.convert(tgtNotation, tgtSeparator);
+      const converterUH = UnitsHandler.getOrCreate(srcCol);
+      const resCol = converterUH.convert(tgtNotation, tgtSeparator);
       expect(resCol.getTag(DG.TAGS.UNITS), tgtNotation);
       return resCol;
     };

package/src/tests/detectors-tests.ts

@@ -274,13 +274,13 @@ MWRSWY-CKHP`;
     await _testDf(readSamples(Samples.fastaCsv), {
       'Sequence': new PosCol(NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false),
     });
-  });
+  }, {skipReason: 'GROK-13851: Unhandled exceptions'});
 
   test('samplesFastaFasta', async () => {
     await _testDf(readSamples(Samples.fastaFasta), {
       'sequence': new PosCol(NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false),
     });
-  });
+  }, {skipReason: 'GROK-13851: Unhandled exceptions'});
 
   // peptidesComplex contains monomers with spaces in AlignedSequence columns, which are forbidden
   // test('samplesPeptidesComplexPositiveAlignedSequence', async () => {

package/src/tests/scoring.ts

@@ -0,0 +1,42 @@
+import * as DG from 'datagrok-api/dg';
+
+import {category, test, expectFloat, before} from '@datagrok-libraries/utils/src/test';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {sequenceIdentityScoring, sequenceSimilarityScoring} from '../package';
+import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+category('Scoring', () => {
+  const sequence = 'sequence';
+  const expectedSimilarity = 'expected_similarity';
+  const expectedIdentity = 'expected_identity';
+  const table = DG.DataFrame.fromCsv(`${sequence},${expectedSimilarity},${expectedIdentity}
+  PEPTIDE1{Aca.Orn.gGlu.Pqa.D-His_1Bn.dH.hHis.4Abz.D-Tic.D-Dap.Y.Iva.meS.F.P.F.D-1Nal}$$$$,1.0,1.0
+  PEPTIDE1{Iva.Gly_allyl.gGlu.Pqa.D-Dip.dH.hHis.4Abz.D-aHyp.D-Dap.Y.Iva.I.Tyr_26diMe.P.Asu.meC}$$$$,0.68,0.53
+  PEPTIDE1{[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal]}$$$$V2.0,0.34,0.0
+  `);
+  const seqCol: DG.Column<string> = table.getCol(sequence);
+  seqCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+  seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+  const reference = seqCol.get(0)!;
+
+  before(async () => {
+    const monomerLibHelper = await getMonomerLibHelper();
+    await monomerLibHelper.loadLibraries(true);
+  });
+
+  test('Identity', async () => {
+    const scoresCol = await sequenceIdentityScoring(table, seqCol, reference);
+    for (let i = 0; i < scoresCol.length; i++) {
+      expectFloat(scoresCol.get(i)!, table.get(expectedIdentity, i), 0.01,
+        `Wrong identity score for sequence at position ${i}`);
+    }
+  });
+
+  test('Similarity', async () => {
+    const scoresCol = await sequenceSimilarityScoring(table, seqCol, reference);
+    for (let i = 0; i < scoresCol.length; i++) {
+      expectFloat(scoresCol.get(i)!, table.get(expectedSimilarity, i), 0.01,
+        `Wrong similarity score for sequence at position ${i}`);
+    }
+  });
+});

package/src/tests/units-handler-get-region.ts

@@ -0,0 +1,116 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {ALPHABET, NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+category('UnitsHandler: getRegion', () => {
+  const data: {
+    [testName: string]: {
+      srcCsv: string,
+      startIdx: number | null,
+      endIdx: number | null,
+      tgtCsv: string,
+      units: NOTATION,
+      alphabet: ALPHABET | null, /* alphabet is not applicable for units 'helm' */
+
+      positionNames?: { tag: string | null, start: string | null, end: string | null }
+    }
+  } = {
+    'fastaDna': {
+      srcCsv: `seq
+ATTCGT
+ACTGCTC
+ATTCCGTA`,
+      startIdx: 2,
+      endIdx: 4,
+      tgtCsv: `seq
+TCG
+TGC
+TCC`,
+      units: NOTATION.FASTA,
+      alphabet: ALPHABET.DNA,
+
+      positionNames: {tag: 'a, b, c, d, e, f, g, h', start: 'c', end: 'e'},
+    },
+    'separatorPt': {
+      srcCsv: `seq
+M-D-Y-K-E-T-L
+M-I-E-V-F-L-F-G-I
+M-M-`,
+      startIdx: 5,
+      endIdx: null,
+      tgtCsv: `seq
+T-L--
+L-F-G-I
+---`,
+      units: NOTATION.SEPARATOR,
+      alphabet: ALPHABET.PT,
+
+      positionNames: {tag: '1, 1A, 1B, 2, 3, 4, 4A, 4A, 4C', start: '4', end: null},
+    },
+    'helm': {
+      srcCsv: `seq
+PEPTIDE1{[meI].[hHis].[Aca].N.T.[dE].[Thr_PO3H2].[Aca].[D-Tyr_Et].[Tyr_ab-dehydroMe].[dV].E.N.[D-Orn]}$$$$
+PEPTIDE1{[meI].[hHis].[Aca].[Cys_SEt].T.[dK].[Thr_PO3H2].[Aca].[Tyr_PO3H2].[D-Chg].[dV].[Phe_ab-dehydro]}$$$$
+PEPTIDE1{[Lys_Boc].[hHis].[Aca].[Cys_SEt].T}$$$$`,
+      startIdx: 3,
+      endIdx: 6,
+      tgtCsv: `seq
+PEPTIDE1{N.T.[dE].[Thr_PO3H2]}$$$$
+PEPTIDE1{[Cys_SEt].T.[dK].[Thr_PO3H2]}$$$$
+PEPTIDE1{[Cys_SEt].T.*.*}$$$$`,
+      units: NOTATION.HELM,
+      alphabet: null,
+
+      positionNames: {tag: null, start: '4', end: '7'}
+    }
+  };
+
+  for (const [testName, testData] of Object.entries(data)) {
+    test(`${testName}-idx`, async () => {
+      const srcDf = DG.DataFrame.fromCsv(testData.srcCsv);
+      const srcSeqCol = srcDf.getCol('seq');
+
+      const semType: string | null = await grok.functions.call('Bio:detectMacromolecule', {col: srcSeqCol});
+      if (semType) srcSeqCol.semType = semType;
+
+      const srcUh = UnitsHandler.getOrCreate(srcSeqCol);
+      const resSeqCol = srcUh.getRegion(testData.startIdx, testData.endIdx, 'regSeq');
+
+      const tgtDf = DG.DataFrame.fromCsv(testData.tgtCsv);
+      const tgtSeqCol = tgtDf.getCol('seq');
+
+      expect(srcSeqCol.getTag(DG.TAGS.UNITS), testData.units);
+      expect(resSeqCol.getTag(DG.TAGS.UNITS), testData.units);
+      expect(srcSeqCol.getTag(TAGS.alphabet), testData.alphabet);
+      expect(resSeqCol.getTag(TAGS.alphabet), testData.alphabet);
+      expectArray(resSeqCol.toList(), tgtSeqCol.toList());
+    });
+
+    if (testData.positionNames) {
+      test(`${testName}-positionNames`, async () => {
+        const srcDf = DG.DataFrame.fromCsv(testData.srcCsv);
+        const srcSeqCol = srcDf.getCol('seq');
+        if (testData.positionNames!.tag)
+          srcSeqCol.setTag(TAGS.positionNames, testData.positionNames!.tag);
+
+        const semType: string | null = await grok.functions.call('Bio:detectMacromolecule', {col: srcSeqCol});
+        if (semType) srcSeqCol.semType = semType;
+
+        const resSeqCol = await grok.functions.call('Bio:getRegion',
+          {sequence: srcSeqCol, start: testData.positionNames!.start, end: testData.positionNames!.end});
+
+        const tgtDf = DG.DataFrame.fromCsv(testData.tgtCsv);
+        const tgtSeqCol = tgtDf.getCol('seq');
+
+        expect(srcSeqCol.getTag(DG.TAGS.UNITS), testData.units);
+        expect(resSeqCol.getTag(DG.TAGS.UNITS), testData.units);
+        expect(srcSeqCol.getTag(TAGS.alphabet), testData.alphabet);
+        expect(resSeqCol.getTag(TAGS.alphabet), testData.alphabet);
+        expectArray(resSeqCol.toList(), tgtSeqCol.toList());
+      });
+    }
+  }
+});

package/src/utils/cell-renderer.ts

@@ -26,6 +26,7 @@ import * as C from './constants';
 
 import {_package, getBioLib} from '../package';
 import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {getSplitter} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
 
 
 type TempType = { [tagName: string]: any };
@@ -142,8 +143,11 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     // Cell renderer settings
     const tempMonomerWidth: string | null = tableColTemp[tempTAGS.monomerWidth];
     const monomerWidth: string = (tempMonomerWidth != null) ? tempMonomerWidth : 'short';
-    if (monomerWidth === 'short')
-      maxLengthOfMonomer = tableColTemp[mmcrTemps.maxMonomerLength] ?? _package.properties.MaxMonomerLength;
+    if (monomerWidth === 'short') {
+      // Renderer can start to work before Bio package initialized, in that time _package.properties is null.
+      // TODO: Render function is available but package init method is not completed
+      maxLengthOfMonomer = tableColTemp[mmcrTemps.maxMonomerLength] ?? _package.properties?.MaxMonomerLength ?? 4;
+    }
 
 
     let seqColTemp: MonomerPlacer = tableCol.temp[tempTAGS.bioSeqCol];
@@ -205,36 +209,6 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
         ((tempReferenceSequence != null) && (tempReferenceSequence != '')) ?
           tempReferenceSequence : tempCurrentWord ?? '');
 
-      // let maxLengthWords: { [pos: number]: number } = {};
-      // if (tableCol.getTag(rndrTAGS.calculatedCellRender) !== splitLimit.toString()) {
-      //   let sampleCount = 0;
-      //   while (sampleCount < Math.min(tableCol.length, 100)) {
-      //     const rowIdx: number = sampleCount;
-      //     const column = tableCol.get(rowIdx);
-      //     const subParts: string[] = splitterFunc(column);
-      //     for (const [index, amino] of subParts.entries()) {
-      //       const textSize = monomerToShortFunction(amino, maxLengthOfMonomer).length * 7 + gapRenderer;
-      //       if (textSize > (maxLengthWords[index] ?? 0))
-      //         maxLengthWords[index] = textSize;
-      //       if (index > maxIndex) maxIndex = index;
-      //     }
-      //     sampleCount += 1;
-      //   }
-      //   const minLength = 3 * 7;
-      //   for (let i = 0; i <= maxIndex; i++) {
-      //     if (maxLengthWords[i] < minLength) maxLengthWords[i] = minLength;
-      //     const maxLengthWordSum: { [pos: number]: number } = {};
-      //     maxLengthWordSum[0] = maxLengthWords[0];
-      //     for (let i = 1; i <= maxIndex; i++) maxLengthWordSum[i] = maxLengthWordSum[i - 1] + maxLengthWords[i];
-      //     colTemp[tempTAGS.bioSumMaxLengthWords] = maxLengthWordSum;
-      //     colTemp[tempTAGS.bioMaxIndex] = maxIndex;
-      //     colTemp[tempTAGS.bioMaxLengthWords] = maxLengthWords;
-      //     tableCol.setTag(rndrTAGS.calculatedCellRender, splitLimit.toString());
-      //   }
-      // } else {
-      //   maxLengthWords = colTemp[tempTAGS.bioMaxLengthWords];
-      // }
-
       const subParts: ISeqSplitted = splitterFunc(value);
       /* let x1 = x; */
       let color = undefinedColor;
@@ -292,14 +266,15 @@ export class MacromoleculeDifferenceCellRenderer extends DG.GridCellRenderer {
     const cell = gridCell.cell;
     const tableCol = gridCell.tableColumn as DG.Column<string>;
     const s: string = cell.value ?? '';
+    const separator = tableCol.tags[bioTAGS.separator];
+    const units: string = tableCol.tags[DG.TAGS.UNITS];
     w = getUpdatedWidth(grid, g, x, w);
     //TODO: can this be replaced/merged with splitSequence?
     const [s1, s2] = s.split('#');
-    const uh = UnitsHandler.getOrCreate(tableCol);
-    const splitter = uh.getSplitter();
+    const splitter = getSplitter(units, separator);
     const subParts1 = splitter(s1);
     const subParts2 = splitter(s2);
-    drawMoleculeDifferenceOnCanvas(g, x, y, w, h, subParts1, subParts2, uh.units);
+    drawMoleculeDifferenceOnCanvas(g, x, y, w, h, subParts1, subParts2, units);
   }
 }
 

package/src/utils/context-menu.ts

@@ -4,7 +4,6 @@ import * as ui from 'datagrok-api/ui';
 
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
 
 import {_package} from '../package';
 
@@ -15,9 +14,9 @@ export function addCopyMenuUI(cell: DG.Cell, menu: DG.Menu): void {
 
   menu.group('Copy')
     .items(tgtNotationList, (tgtNotation) => {
-      const nc = new NotationConverter(cell.column);
+      const ncUH = UnitsHandler.getOrCreate(cell.column);
       const separator = tgtNotation === NOTATION.SEPARATOR ? _package.properties.DefaultSeparator : undefined;
-      const converter = nc.getConverter(tgtNotation as NOTATION, separator);
+      const converter = ncUH.getConverter(tgtNotation as NOTATION, separator);
       const tgtSeq = converter(cell.value);
 
       if (!navigator.clipboard) {

package/src/utils/convert.ts

@@ -5,7 +5,6 @@ import * as grok from 'datagrok-api/grok';
 import $ from 'cash-dom';
 import {Subscription} from 'rxjs';
 import {NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {expect} from '@datagrok-libraries/utils/src/test';
 
@@ -22,8 +21,8 @@ export function convert(col?: DG.Column): void {
   let tgtCol = col ?? grok.shell.t.columns.bySemType('Macromolecule')!;
   if (!tgtCol)
     throw new Error('No column with Macromolecule semantic type found');
-  let converter = new NotationConverter(tgtCol);
-  let currentNotation: NOTATION = converter.notation;
+  let converterUH = UnitsHandler.getOrCreate(tgtCol);
+  let currentNotation: NOTATION = converterUH.notation;
   const dialogHeader = ui.divText(
     'Current notation: ' + currentNotation,
     {
@@ -47,8 +46,8 @@ export function convert(col?: DG.Column): void {
     }
 
     tgtCol = newCol;
-    converter = new NotationConverter(tgtCol);
-    currentNotation = converter.notation;
+    converterUH = UnitsHandler.getOrCreate(tgtCol);
+    currentNotation = converterUH.notation;
     if (currentNotation === NOTATION.HELM)
       separatorInput.value = '/'; // helm monomers can have - in the name like D-aThr;
     dialogHeader.textContent = 'Current notation: ' + currentNotation;
@@ -117,8 +116,8 @@ export function convert(col?: DG.Column): void {
  * @param {string | null} separator Separator for SEPARATOR notation
  */
 export async function convertDo(srcCol: DG.Column, targetNotation: NOTATION, separator?: string): Promise<DG.Column> {
-  const converter = new NotationConverter(srcCol);
-  const newColumn = converter.convert(targetNotation, separator);
+  const converterUH = UnitsHandler.getOrCreate(srcCol);
+  const newColumn = converterUH.convert(targetNotation, separator);
   srcCol.dataFrame.columns.add(newColumn);
 
   // Call detector directly to escape some error on detectSemanticTypes