@datagrok/sequence-translator 1.4.5 → 1.4.6

package/files/polytool-rules/rules_example.json

@@ -39,6 +39,6 @@
   },
   {
     "type": "differentFragments",
-    "code": "$4"
+    "code": "$3"
   }
 ]

package/files/samples/HELM.csv

@@ -0,0 +1,6 @@
+HELM
+"PEPTIDE1{[meI].[hHis].[Aca].N.T.[dE].[Aca].[D-Tyr_Et].[Tyr_ab-dehydroMe].[dV].E.N.[D-Orn].[D-aThr].[Phe_4Me]}$PEPTIDE1,PEPTIDE1,15:R2-1:R1$$$V2.0"
+"PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$V2.0",
+PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Phe_ab-dehydro.N.D-Orn.D-aThr.Phe_4Me}$$$$
+"PEPTIDE1{C.A.C.A.C.A.C.A}|PEPTIDE2{C.A.C.A.C.A.C.A}|PEPTIDE3{C.A.C.A.C.A.C.A}|PEPTIDE4{C.A.C.A.C.A.C.A}$PEPTIDE1,PEPTIDE2,3:R3-8:R2|PEPTIDE3,PEPTIDE4,3:R3-8:R2|PEPTIDE1,PEPTIDE3,5:R3-5:R3$$$V2.0"
+"PEPTIDE1{C.A.C.A.C.A.C.A.C.A.C.A}|PEPTIDE2{C.A.C.A.C.A.C.A.C.A.C.A}$PEPTIDE2,PEPTIDE1,1:R1-3:R3|PEPTIDE2,PEPTIDE2,1:R3-12:R2$$$V2.0"

package/files/samples/cyclized.csv

@@ -4,5 +4,6 @@ n,seqs
 3,R-F-C(1)-T-G-H-F-Y-P-C(1)
 4,C(1)-T-G-H-F-H-P-C(1)
 5,R-F-D(2)-T-G-H-F-Y-P-NH2(2)
-6,R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI
-7,R-F-aG(4)-T-G-H-F-Y-P-azG(4)-meI
+6,D(2)-T-G-H-F-Y-P-NH2(2)
+7,R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI
+8,R-F-aG(4)-T-G-H-F-Y-P-azG(4)-meI

package/files/samples/cyclized_MSA.csv

@@ -0,0 +1,5 @@
+n,seqs
+1,R-F-C(1)-Thz-G-H-F-Y-G-P-C(1)-meI-R
+2,R-F-C(1)-T-Thz-H-F-Y-G-P-C(1)-meI-R
+3,R-F-C(1)-T-G-Thz-F-Y-G-P-C(1)-meI-R
+4,R-F-C(1)-T-G-H-Thz-Y-G-P-C(1)-meI-R

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "author": {
     "name": "Alexey Chopovsky",
     "email": "achopovsky@datagrok.ai"
@@ -22,7 +22,7 @@
     }
   ],
   "dependencies": {
-    "@datagrok-libraries/bio": "^5.45.2",
+    "@datagrok-libraries/bio": "^5.45.5",
     "@datagrok-libraries/chem-meta": "^1.2.7",
     "@datagrok-libraries/tutorials": "^1.4.3",
     "@datagrok-libraries/utils": "^4.3.6",
@@ -41,9 +41,9 @@
   "devDependencies": {
     "@datagrok-libraries/helm-web-editor": "^1.1.12",
     "@datagrok-libraries/js-draw-lite": "^0.0.9",
-    "@datagrok/bio": "^2.16.2",
-    "@datagrok/helm": "^2.5.4",
-    "@datagrok/chem": "^1.12.3",
+    "@datagrok/bio": "^2.16.6",
+    "@datagrok/helm": "^2.5.7",
+    "@datagrok/chem": "^1.12.4",
     "@types/jquery": "^3.5.14",
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.202",

package/src/apps/common/model/oligo-toolkit-package.ts

@@ -47,21 +47,28 @@ export class OligoToolkitPackage extends DG.Package implements ITranslationHelpe
     return this._monomerLibWrapper;
   }
 
+  private _initPromise: Promise<void>;
+  public get initPromise(): Promise<void> { return this._initPromise; }
+
   constructor(opts: { debug: boolean } = {debug: false}) {
     super();
     // @ts-ignore
     super._logger = new LoggerWrapper(super.logger, opts.debug);
   }
 
-  private initPromise?: Promise<void>;
+  startInit(initPromise: Promise<void>): void {
+    this._initPromise = initPromise;
+  }
 
   completeInit(seqHelper: ISeqHelper): void {
     this._seqHelper = seqHelper;
   }
 
+  private initLibDataPromise?: Promise<void>;
+
   async initLibData(): Promise<void> {
-    if (!this.initPromise) {
-      this.initPromise = (async () => {
+    if (!this.initLibDataPromise) {
+      this.initLibDataPromise = (async () => {
         const packageSettings = await this.getSettings();
         let monomersPath: string = packageSettings['MonomersPath'];
         if (!monomersPath || !(await grok.dapi.files.exists(monomersPath))) {
@@ -76,7 +83,7 @@ export class OligoToolkitPackage extends DG.Package implements ITranslationHelpe
         this._monomerLibWrapper = new MonomerLibWrapper(this.monomerLib, this.jsonData);
       })();
     }
-    return this.initPromise;
+    return this.initLibDataPromise;
   }
 
   async getTranslationHelper(): Promise<ITranslationHelper> {

package/src/consts.ts

@@ -0,0 +1,12 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+export const enum PolyToolTags {
+  dataRole = 'polytool-data-role',
+}
+
+export const enum PolyToolDataRole {
+  template = 'template',
+  macromolecule = 'macromolecule',
+}

package/src/global.d.ts

@@ -0,0 +1,13 @@
+import * as grokNamespace from 'datagrok-api/grok';
+import * as uiNamespace from 'datagrok-api/ui';
+import * as DGNamespace from 'datagrok-api/dg';
+import * as rxjsNamespace from 'rxjs';
+import $Namespace from 'cash-dom';
+
+declare global {
+    const grok: typeof grokNamespace;
+    const ui: typeof uiNamespace;
+    const DG: typeof DGNamespace;
+    const rjxs: typeof rxjsNamespace;
+    const $: typeof $Namespace;
+}

package/src/package-test.ts

@@ -14,6 +14,7 @@ import './tests/polytool-unrule-tests';
 import './tests/polytool-enumerate-tests';
 import './tests/polytool-enumerate-breadth-tests';
 import './tests/polytool-chain-parse-notation-tests';
+import './tests/polytool-chain-from-notation-tests';
 import './tests/toAtomicLevel-tests';
 
 import {OligoToolkitTestPackage} from './tests/utils';

package/src/package.ts

@@ -24,9 +24,9 @@ import {PolyToolCsvLibHandler} from './polytool/csv-to-json-monomer-lib-converte
 import {ITranslationHelper} from './types';
 import {addContextMenuUI} from './utils/context-menu';
 import {PolyToolConvertFuncEditor} from './polytool/pt-convert-editor';
-import {polyToolUnruleUI} from './polytool/pt-unrule';
 import {CyclizedNotationProvider} from './utils/cyclized';
 import {getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {PolyToolTags} from './consts';
 
 export const _package: OligoToolkitPackage = new OligoToolkitPackage({debug: true}/**/);
 
@@ -34,8 +34,9 @@ let initSequenceTranslatorPromise: Promise<void> | null = null;
 
 //tags: init
 export async function init(): Promise<void> {
-  if (initSequenceTranslatorPromise === null)
-    initSequenceTranslatorPromise = initSequenceTranslatorInt();
+  if (initSequenceTranslatorPromise === null) {
+    _package.startInit(initSequenceTranslatorPromise = initSequenceTranslatorInt());
+  }
   return initSequenceTranslatorPromise;
 }
 
@@ -300,6 +301,6 @@ export async function ptEnumeratorChemApp(): Promise<void> {
 //input: string separator
 export function applyNotationProviderForCyclized(col: DG.Column<string>, separator: string) {
   col.meta.units = NOTATION.CUSTOM;
-  col.tags['pt-role'] = 'template';
+  col.tags[PolyToolTags.dataRole] = 'template';
   col.temp[SeqTemps.notationProvider] = new CyclizedNotationProvider(separator, _package.seqHelper);
 }

package/src/polytool/pt-conversion.ts

@@ -4,6 +4,7 @@ import * as DG from 'datagrok-api/dg';
 
 import wu from 'wu';
 
+import {cleanupHelmSymbol} from '@datagrok-libraries/bio/src/helm/utils';
 import {HelmTypes, PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
 import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {IMonomerLib, IMonomerLibBase, Monomer, MonomerLibData, RGroup} from '@datagrok-libraries/bio/src/types';
@@ -11,8 +12,8 @@ import {RDModule, RDMol, RDReaction, MolList, RDReactionResult} from '@datagrok-
 import {HELM_REQUIRED_FIELD as REQ, HELM_OPTIONAL_FIELDS as OPT, HELM_RGROUP_FIELDS, HELM_OPTIONAL_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
 import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
-import {HelmMol, HelmType, JSDraw2ModuleType, OrgType} from '@datagrok-libraries/bio/src/helm/types';
-import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {HelmAtom, HelmBio, HelmMol, HelmType, JSDraw2ModuleType, OrgType} from '@datagrok-libraries/bio/src/helm/types';
+import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {Rules, RuleLink, RuleReaction} from './pt-rules';
 import {InvalidReactionError, MonomerNotFoundError} from './types';
@@ -22,81 +23,128 @@ import {_package} from '../package';
 declare const JSDraw2: JSDraw2ModuleType;
 declare const org: OrgType;
 
+type Linkage = {
+  fChain: number,
+  sChain: number,
+  /** Continuous 1-based numbering */ fMonomer: number,
+  /** Continuous 1-based numbering */ sMonomer: number,
+  fR: number,
+  sR: number
+}
+
+type PolyToolBio = HelmBio & { i: number, j: number };
 
 export class Chain {
-  linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[];
+  linkages: Linkage[];
   monomers: string[][];
-  mol: HelmMol | null;
+  mol: HelmMol;
 
   constructor(
     monomers: string[][],
-    linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[],
-    mol: HelmMol | null) {
+    linkages: Linkage[],
+    mol: HelmMol) {
     this.linkages = linkages;
     this.monomers = monomers;
     this.mol = mol;
   }
 
-  static fromHelm(helm: string) {
-    const fragmentation = helm.split('$');
+  /** Parse harmonized sequence (template) from pseudo helm */
+  static parseHelm(helm: string, helmHelper: IHelmHelper) {
+    const ea = /(\w+\{.*\})\$(.*)\$(.*)\$(.*)\$/g.exec(helm)!;
+    // const fragmentation = helm.split('$');
+    const fragmentation = [ea[1], ea[2], ea[3], ea[4]];
+
     const rawFragments = fragmentation[0].split('|');
     const rawLinkages = fragmentation[1].split('|');
 
     const monomers = new Array<Array<string>>(rawFragments.length);
-    const linkages: {
-      fChain: number,
-      sChain: number,
-      fMonomer: number,
-      sMonomer: number,
-      fR: number,
-      sR: number
-    }[] = [];
+    const linkages: Linkage[] = [];
+
+    const resHwe = helmHelper.createHelmWebEditor();
+    const resMol = resHwe.editor.m;
 
+    let counter = 0;
+    const p = new JSDraw2.Point(0, 0);
     //HELM parsing
     for (let i = 0; i < rawFragments.length; i++) {
       const idxStart = rawFragments[i].indexOf('{');
       const idxEnd = rawFragments[i].indexOf('}');
 
-      monomers[i] = rawFragments[i].slice(idxStart + 1, idxEnd).split('.');
+      monomers[i] = rawFragments[i].slice(idxStart + 1, idxEnd).split('.').map((s) => cleanupHelmSymbol(s));
+      for (let j = 0; j < monomers[i].length; j++) {
+        const elem = monomers[i][j];
+        const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+        const atom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+        resMol.addAtom(atom);
+
+        if (j !== 0) {
+          const atom1 = resMol.atoms[counter - 1];
+          const atom2 = resMol.atoms[counter];
+          const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+          bond.r1 = 2;
+          bond.r2 = 1;
+          resMol.addBond(bond);
+        }
+
+        counter++;
+        p.x += JSDraw2.Editor.BONDLENGTH; // Inspired by HELMWebEditor
+      }
+      p.y += 4 * JSDraw2.Editor.BONDLENGTH; // Inspired by HELMWebEditor
     }
 
     //HELM parsing
     for (let i = 0; i < rawLinkages.length; i++) {
       if (rawLinkages[i] !== '' && rawLinkages[i] !== 'V2.0') {
         const rawData = rawLinkages[i].split(',');
-        const seq1 = (rawData[0].replace('PEPTIDE', '') as unknown as number) - 1;
-        const seq2 = (rawData[1].replace('PEPTIDE', '') as unknown as number) - 1;
-        const rawDataConnctions = rawData[2].split('-');
-        const rawDataConnction1 = rawDataConnctions[0].split(':');
-        const rawDataConnction2 = rawDataConnctions[1].split(':');
+        const fChainIdx = parseInt(rawData[0].replace('PEPTIDE', '')) - 1;
+        const sChainIdx = parseInt(rawData[1].replace('PEPTIDE', '')) - 1;
+        const rawDataConnections = rawData[2].split('-');
+        const rawDataConnection1 = rawDataConnections[0].split(':');
+        const rawDataConnection2 = rawDataConnections[1].split(':');
 
         linkages.push({
-          fChain: seq1,
-          sChain: seq2,
-          fMonomer: rawDataConnction1[0] as unknown as number,
-          sMonomer: rawDataConnction2[0] as unknown as number,
-          fR: rawDataConnction1[1].replace('R', '') as unknown as number,
-          sR: rawDataConnction2[1].replace('R', '') as unknown as number,
+          fChain: fChainIdx,
+          sChain: sChainIdx,
+          fMonomer: getOuterIdx(parseInt(rawDataConnection1[0]), fChainIdx, monomers),
+          sMonomer: getOuterIdx(parseInt(rawDataConnection2[0]), sChainIdx, monomers),
+          fR: parseInt(rawDataConnection1[1].replace('R', '')),
+          sR: parseInt(rawDataConnection2[1].replace('R', '')),
         });
       }
     }
 
-    return new Chain(monomers, linkages, null);
+    for (let i = 0; i < linkages.length; i++) {
+      const atom1 = resMol.atoms[linkages[i].fMonomer - 1];
+      const atom2 = resMol.atoms[linkages[i].sMonomer - 1];
+      const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+      bond.r1 = linkages[i].fR;
+      bond.r2 = linkages[i].sR;
+      resMol.addBond(bond);
+    }
+
+    return new Chain(monomers, linkages, resMol);
   }
 
-  static fromNotation(sequence: string, rules: Rules): Chain {
+  /** Get macromolecule from harmonized sequence (template) */
+  applyRules(rules: Rules): Chain {
+    // Clone this
+    const resMonomers: string[][] = this.monomers.map((mL) => [...mL]);
+    const resLinkages: Linkage[] = [...this.linkages];
+    const resMol: HelmMol = this.mol.clone();
+
+    throw new Error('not implemented');
+
+    const chain = new Chain(resMonomers, resLinkages, resMol);
+    return chain;
+  }
+
+  /** @deprecated Use {@link parseNotation} and {@link applyRules} instead. */
+  static fromNotation(sequence: string, rules: Rules, helmHelper: IHelmHelper): Chain {
     const heterodimerCode = rules.heterodimerCode;
     const homodimerCode = rules.homodimerCode;
-    const mainFragments: string[] = [];
 
-    const linkages: {
-      fChain: number,
-      sChain: number,
-      fMonomer: number,
-      sMonomer: number,
-      fR: number,
-      sR: number
-    }[] = [];
+    const mainFragments: string[] = [];
+    const linkages: Linkage[] = [];
 
     //NOTICE: this works only with simple single heterodimers
     const heterodimeric = heterodimerCode !== null ? sequence.split(`(${rules.heterodimerCode!})`) : '';
@@ -167,6 +215,11 @@ export class Chain {
 
     const monomersAll: string[][] = [];
 
+    const resHwe = helmHelper.createHelmWebEditor();
+    const resMol = resHwe.editor.m;
+
+    let counter = 0;
+    const p = new JSDraw2.Point(0, 0);
     for (let i = 0; i < monomers.length; i++) {
       const linkedPositions = this.getLinkedPositions(monomers[i], rules.reactionRules);
       const [monomersCycled, allPos1, allPos2, ruleN] =
@@ -175,14 +228,41 @@ export class Chain {
       if (allPos1.length >= 1) {
         const ch1 = new Array<string>(allPos2[0] - 1);
         const ch2 = new Array<string>(monomersCycled.length - allPos2[0]);
-        for (let j = 0; j < allPos2[0] - 1; j++)
-          ch1[j] = monomersCycled[j];
+        for (let j = 0; j < allPos2[0] - 1; j++) {
+          const elem = ch1[j] = monomersCycled[j];
+          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom: HelmAtom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          resMol.addAtom(atom);
 
-        for (let j = allPos2[0]; j < monomersCycled.length; j++)
-          ch2[j - allPos2[0]] = monomersCycled[j];
+          if (j > 0) {
+            const atom1 = resMol.atoms[counter - 1];
+            const atom2 = resMol.atoms[counter];
+            const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+            bond.r1 = 2;
+            bond.r2 = 1;
+            resMol.addBond(bond);
+          }
+          counter++;
+        }
+
+        for (let j = allPos2[0]; j < monomersCycled.length; j++) {
+          const elem = ch2[j - allPos2[0]] = monomersCycled[j];
+          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom: HelmAtom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          resMol.addAtom(atom);
 
+          if (j > allPos2[0]) {
+            const atom1 = resMol.atoms[counter - 1];
+            const atom2 = resMol.atoms[counter];
+            const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+            bond.r1 = 2;
+            bond.r2 = 1;
+            resMol.addBond(bond);
+          }
+          counter++;
+        }
 
-        ch1[allPos1[0] - 1] = rules.reactionRules[ruleN[0]].name;
+        resMol.atoms[allPos1[0] - 1].elem = ch1[allPos1[0] - 1] = rules.reactionRules[ruleN[0]].name;
 
         for (let j = 0; j < linkages.length; j++) {
           if (linkages[j].fMonomer > allPos2[0]) {
@@ -222,32 +302,46 @@ export class Chain {
         monomersAll.push(ch1);
         monomersAll.push(ch2);
       } else {
+        for (let j = 0; j < monomers[i].length; j++) {
+          const elem = monomers[i][j];
+          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom: HelmAtom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          resMol.addAtom(atom);
+
+          if (j > 0) {
+            const atom1 = resMol.atoms[counter - 1];
+            const atom2 = resMol.atoms[counter];
+            const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+            bond.r1 = 2;
+            bond.r2 = 1;
+            resMol.addBond(bond);
+          }
+          counter++;
+        }
         monomersAll.push(monomers[i]);
       }
     }
 
-    const chain = new Chain(monomersAll, linkages, null);
+    for (const l of linkages) {
+      const atom1 = resMol.atoms[l.fMonomer - 1];
+      const atom2 = resMol.atoms[l.sMonomer - 1];
+      const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+      bond.r1 = l.fR;
+      bond.r2 = l.sR;
+      resMol.addBond(bond);
+    }
+
+    const chain = new Chain(monomersAll, linkages, resMol);
     return chain;
   }
 
-  static async parseNotation(sequence: string): Promise<Chain> {
+  /** Parse harmonized sequence notation (template)  */
+  static parseNotation(sequence: string, helmHelper: IHelmHelper): Chain {
     const mainFragments: string[][] = [];
 
-    const linkages: {
-      fChain: number,
-      sChain: number,
-      fMonomer: number,
-      sMonomer: number,
-      fR: number,
-      sR: number
-    }[] = [];
-
+    const linkages: Linkage[] = [];
 
-    const hh = await getHelmHelper();
-    // const sampleHwe = hh.createHelmWebEditor();
-    // sampleHwe.editor.setHelm('PEPTIDE1{R.P.D.[meI]}$$$$');
-
-    const resHwe = hh.createHelmWebEditor();
+    const resHwe = helmHelper.createHelmWebEditor();
     const resMol = resHwe.editor.m;
 
     const rxp = /(\(.\d+\))?\{[^\}]*\}/g;
@@ -268,17 +362,18 @@ export class Chain {
     for (let i = 0; i < seqs.length; i++) {
       const splMonomers = seqs[i].split('-');
       const monomers: string [] = new Array<string>(splMonomers.length);
+      let spmCount: number = 0;
       for (let j = 0; j < splMonomers.length; j++) {
         const monomer = splMonomers[j].replace('{', '').replace('}', '');
         if (monomer !== '') {
           monomers[j] = monomer;
           counter++;
+          spmCount++;
         } else {
           linkages.push({fChain: i, sChain: i + 1, fMonomer: counter, sMonomer: counter + 1, fR: 1, sR: 1});
         }
       }
-
-      mainFragments.push(monomers);
+      mainFragments.push(monomers.slice(0, spmCount));
     }
 
     counter = 0;
@@ -287,7 +382,7 @@ export class Chain {
       for (let j = 0; j < mainFragments[i].length; j++) {
         if (!!mainFragments[i][j]) {
           const elem = mainFragments[i][j];
-          const bio = {type: HelmTypes.AA, i: i, j: j};
+          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
           const atom = new JSDraw2.Atom<HelmType>(p, elem, bio);
           resMol.addAtom(atom);
 
@@ -347,10 +442,12 @@ export class Chain {
     return res;
   }
 
+  /** Gets harmonized sequence (template) pseudo helm */
   getNotationHelm(): string {
     return this.getHelm();
   }
 
+  /** Gets harmonized sequence (template) pseudo helm */
   getHelm(): string {
     let helm = '';
     for (let i = 0; i < this.monomers.length; i++) {
@@ -374,17 +471,18 @@ export class Chain {
       if (i > 0)
         helm += '|';
       helm += `PEPTIDE${this.linkages[i].fChain + 1},PEPTIDE${this.linkages[i].sChain + 1},`;
-      helm += `${this.linkages[i].fMonomer}:R${this.linkages[i].fR}-`;
-      helm += `${this.linkages[i].sMonomer}:R${this.linkages[i].sR}`;
+
+      helm += `${getInnerIdx(this.linkages[i].fMonomer - 1, this.monomers)[0] + 1}:R${this.linkages[i].fR}-`;
+      helm += `${getInnerIdx(this.linkages[i].sMonomer - 1, this.monomers)[0] + 1}:R${this.linkages[i].sR}`;
     }
 
-    helm += '$$$';
+    helm += '$$$' + 'V2.0';
     return helm;
   }
 
   getNotation(): string {
-    const atoms = this.mol!.atoms;
-    const bonds = this.mol!.bonds;
+    const atoms = this.mol.atoms;
+    const bonds = this.mol.bonds;
     const chains: number[] = [];
     const specialBonds: number[] = [];
     for (let i = 0; i < bonds.length!; i++) {
@@ -545,15 +643,48 @@ export class Chain {
 
     return [monomers, allPos1, allPos2, rule];
   }
+
+  public check(throwError: boolean = false): string[] {
+    const errors: string[] = [];
+
+    const chainsMonomerCount = this.monomers.map((ch) => ch.length).reduce((acc, curr) => acc + curr, 0);
+    if (this.mol.atoms.length !== chainsMonomerCount)
+      errors.push(`The mol atoms count ${this.mol.atoms.length} does not match ` +
+        `the total number ${chainsMonomerCount} of chains' monomers.`);
+
+    const internalBondsCount = this.monomers.map((ch) => ch.length - 1).reduce((acc, curr) => acc + curr, 0);
+    const chainsBondCount = internalBondsCount + this.linkages.length;
+    if (this.mol.bonds.length !== chainsBondCount)
+      errors.push(`The mol bonds count ${this.mol.bonds.length} does not match ` +
+        `the total number ${chainsBondCount} in- and inter-chain linkages.`);
+
+    let counter: number = 0;
+    for (let spIdx = 0; spIdx < this.monomers.length; ++spIdx) {
+      const chain = this.monomers[spIdx];
+      for (let mIntIdx = 0; mIntIdx < chain.length; ++mIntIdx) {
+        try {
+          const m = chain[mIntIdx];
+          const a = this.mol.atoms[counter];
+          if (a.bio!.continuousId !== counter)
+            errors.push(`Atom #${counter} has incorrect .bio.continuousId: ${a.bio!.continuousId}.`);
+          if (a.elem !== m)
+            errors.push(`Atom #${counter} elem: '${a.elem}' does not match chain monomer: '${m}'.`);
+        } finally { counter++; }
+      }
+    }
+    if (throwError && errors.length > 0)
+      throw new Error(`Chain errors:\n${errors.map((e) => `  ${e}`).join('\n')}`);
+    return errors;
+  }
 }
 
 /** The main PolyTool convert engine. Returns list of Helms. Covered with tests. */
-export function doPolyToolConvert(sequences: string[], rules: Rules): string[] {
+export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper: IHelmHelper): string[] {
   const helms = new Array<string>(sequences.length);
   for (let i = 0; i < sequences.length; i++) {
     try {
       if (sequences[i] == null) { helms[i] = ''; } else {
-        const chain = Chain.fromNotation(sequences[i], rules);
+        const chain = Chain.fromNotation(sequences[i], rules, helmHelper);
         helms[i] = chain.getHelm();
       }
     } catch (err: any) {
@@ -710,3 +841,24 @@ export async function getOverriddenLibrary(rules: Rules): Promise<IMonomerLibBas
     'ST-PT-reactions.' + wu.repeat(1).map(() => Math.floor((Math.random() * 36)).toString(36)).take(4).toArray().join(''));
   return overriddenMonomerLib;
 }
+
+/** Gets 0-based in-index (simple polymer) of out-index (continuous) {@link idx} */
+export function getInnerIdx(outIdx: number, monomers: string[][]): [number, number] {
+  // let prevSpCount = 0;
+  // for (let spI = 0; spI < monomers.length && idx >= (prevSpCount + monomers[spI].length); ++spI)
+  //   prevSpCount += monomers[spI].length;
+  // return idx - prevSpCount;
+  let inIdx = outIdx;
+  let spIdx: number;
+  for (spIdx = 0; spIdx < monomers.length && inIdx >= monomers[spIdx].length; ++spIdx)
+    inIdx -= monomers[spIdx].length;
+  return [inIdx, spIdx];
+}
+
+/** Gets 0-based out-index of 0-based in-index {@link inIdx} monomer of simple polymer {@link spIdx} */
+export function getOuterIdx(inIdx: number, spIdx: number, monomers: string[][]): number {
+  let outIdx = 0;
+  for (let i = 0; i < spIdx; ++i)
+    outIdx += monomers[i].length;
+  return outIdx + inIdx;
+}