@datagrok/sequence-translator 1.5.3 → 1.6.0

package/src/polytool/conversion/pt-conversion.ts

@@ -1,10 +1,8 @@
 
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
-
 import {Rules} from './pt-rules';
 import {Chain} from './pt-chain';
-
 import {_package} from '../../package';
 
 /** The main PolyTool convert engine. Returns list of Helms. Covered with tests. */
@@ -13,7 +11,8 @@ export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper:
   for (let i = 0; i < sequences.length; i++) {
     try {
       if (sequences[i] == null) { helms[i] = ''; } else {
-        const chain = Chain.fromNotation(sequences[i], rules, helmHelper);
+        const chain = Chain.fromSeparator(sequences[i], helmHelper);
+        chain.applyRules(rules);
         helms[i] = chain.getHelm();
       }
     } catch (err: any) {

package/src/polytool/conversion/pt-misc.ts

@@ -1,16 +1,11 @@
-import * as grok from 'datagrok-api/grok';
-
-import wu from 'wu';
-import {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';
-import {RDModule, RDMol, RDReaction, MolList, RDReactionResult} from '@datagrok-libraries/chem-meta/src/rdkit-api';
-import {HELM_REQUIRED_FIELD as REQ,
-  HELM_OPTIONAL_FIELDS as OPT, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
-import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
-import {Rules, RuleReaction, getMonomerPairs} from './pt-rules';
-import {InvalidReactionError, MonomerNotFoundError} from '../types';
-import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+export type Linkage = {
+  fChain: number,
+  sChain: number,
+  /** Continuous 1-based numbering */ fMonomer: number,
+  /** Continuous 1-based numbering */ sMonomer: number,
+  fR: number,
+  sR: number
+}
 
 /** Gets 0-based in-index (simple polymer) of out-index (continuous) {@link idx} */
 export function getInnerIdx(outIdx: number, monomers: string[][]): [number, number] {
@@ -32,172 +27,3 @@ export function getOuterIdx(inIdx: number, spIdx: number, monomers: string[][]):
     outIdx += monomers[i].length;
   return outIdx + inIdx;
 }
-
-function getMonomersMolBlocks(monomer1: Monomer, monomer2: Monomer): [string, string] {
-  const mb1 = monomer1.molfile;
-  let mb2 = monomer2.molfile;
-  const addGroups = monomer1.rgroups.length;
-
-  //mol v2000 monomer
-  const rgpIdx = mb2.indexOf('M  RGP');
-  if (rgpIdx !== -1) {
-    const groupsCountStr = mb2.substring(rgpIdx + 6, rgpIdx + 9);
-    const groupsCount = Number(groupsCountStr);
-
-    for (let i = 0; i < groupsCount; i++) {
-      const start = rgpIdx + 9 + 4 + i * 8;
-      const end = rgpIdx + 9 + 8 + i * 8;
-      const rGroupSpecifier = mb2.substring(start, end);
-      const groupPosition = Number(rGroupSpecifier) + addGroups;
-      const digits = Math.floor(Math.log10(groupPosition) + 1);
-      const newSpecifier = ' '.repeat(4 - digits) + String(groupPosition);
-      mb2 = mb2.substring(0, start) + newSpecifier + mb2.substring(end, mb2.length);
-    }
-  }
-
-  //TODO: same for v3000 monomer
-
-  return [mb1, mb2];
-}
-
-function getSyntheticMolBlock(rdkit: RDModule, reaction: string,
-  mb1: string, mb2: string, monomerName: string): string {
-  let rxn: RDReaction | null = null;
-  let mols: MolList | null = null;
-  let mol1: RDMol | null = null;
-  let mol2: RDMol | null = null;
-  let rctns: RDReactionResult | null = null;
-  let molP: RDMol | null = null;
-  let molBlock = '';
-
-  try {
-    rxn = rdkit.get_rxn(reaction);
-    if (!rxn) throw new InvalidReactionError(reaction);
-    mols = new rdkit.MolList();
-    mol1 = rdkit.get_mol(mb1!);
-    mol2 = rdkit.get_mol(mb2!);
-    mols.append(mol1!);
-    mols.append(mol2!);
-
-    rctns = rxn.run_reactants(mols, 1);
-    //const size = rctns.size();
-    const element = rctns.get(0);
-
-    molP = element.next();
-    molBlock = molP?.get_molblock();//molP?.get_v3Kmolblock();//
-  } catch (err: any) {
-    const [errMsg, _errStack] = errInfo(err);
-    grok.shell.error(`Can not assemble monomer '${monomerName}': ${errMsg}.`);
-    throw err;
-  } finally {
-    rxn?.delete();
-    mols?.delete();
-    mol1?.delete();
-    mol2?.delete();
-    rctns?.delete();
-    molP?.delete();
-  }
-
-  return molBlock;
-}
-
-function getNewGroups(monomer1: Monomer, monomer2: Monomer): RGroup[] {
-  const groups = new Array<RGroup>(monomer1?.rgroups.length! + monomer2?.rgroups.length!);
-  const length1 = monomer1?.rgroups.length!;
-  const length2 = monomer2?.rgroups.length!;
-
-  for (let i = 0; i < length1; i++)
-    groups[i] = monomer1?.rgroups[i]!;
-
-  for (let i = 0; i < length2; i++) {
-    const rGroupSpecifier = monomer2?.rgroups[i]!.label.replace('R', '');
-    const groupPosition = Number(rGroupSpecifier) + length1;
-    const group: RGroup = {
-      //@ts-ignore
-      [HELM_RGROUP_FIELDS.CAP_GROUP_SMILES_UPPERCASE]: monomer2?.rgroups[i].capGroupSMILES
-        .replace(rGroupSpecifier, String(groupPosition)),
-      [HELM_RGROUP_FIELDS.ALTERNATE_ID]: monomer2?.rgroups[i].alternateId
-        .replace(rGroupSpecifier, String(groupPosition)),
-      [HELM_RGROUP_FIELDS.CAP_GROUP_NAME]: monomer2?.rgroups[i].capGroupName,
-      [HELM_RGROUP_FIELDS.LABEL]: monomer2?.rgroups[i].label.replace(rGroupSpecifier, String(groupPosition)),
-    };
-
-    groups[i + length1] = group;
-  }
-
-  return groups;
-}
-
-export function getNewMonomers(rdkit: RDModule, mLib: IMonomerLib, rule: RuleReaction): [string[], Monomer[]] {
-  const reacSmarts = rule.reaction;
-  const monomerName = rule.name;
-
-  const [firstMonomers, secondMonomers] = getMonomerPairs(rule);
-
-  const monomerNames = new Array<string>(firstMonomers.length);
-  const resMonomers = new Array<Monomer>(firstMonomers.length);
-
-  for (let i = 0; i < firstMonomers.length; i ++) {
-    const monomer1 = mLib.getMonomer('PEPTIDE', firstMonomers[i]);
-    if (!monomer1) throw new MonomerNotFoundError('PEPTIDE', firstMonomers[i]);
-    const monomer2 = mLib.getMonomer('PEPTIDE', secondMonomers[i]);
-    if (!monomer2) throw new MonomerNotFoundError('PEPTIDE', secondMonomers[i]);
-
-    const [mb1, mb2] = getMonomersMolBlocks(monomer1!, monomer2!);
-    const molBlock = getSyntheticMolBlock(rdkit, reacSmarts, mb1, mb2, monomerName);
-    const groups: RGroup[] = getNewGroups(monomer1!, monomer2!);
-
-    const resMonomer: Monomer = {
-      [REQ.SYMBOL]: monomerName,
-      [REQ.NAME]: monomerName,
-      [REQ.MOLFILE]: molBlock,
-      [REQ.AUTHOR]: '',
-      [REQ.ID]: 0,
-      [REQ.RGROUPS]: groups,
-      [REQ.SMILES]: '',
-      [REQ.POLYMER_TYPE]: 'PEPTIDE',
-      [REQ.MONOMER_TYPE]: 'Backbone',
-      [REQ.CREATE_DATE]: null,
-      // // @ts-ignore
-      // lib: {source: 'Reaction'},
-    };
-
-    resMonomer[OPT.META] = Object.assign(resMonomer[OPT.META] ?? {},
-      {'colors': {'default': {line: '#2083D5', text: '#2083D5', background: '#F2F2F5'}}});
-
-    monomerNames[i] = monomerName;
-    resMonomers[i] = resMonomer;
-  }
-
-  return [monomerNames, resMonomers];
-}
-
-export async function getOverriddenLibrary(rules: Rules): Promise<IMonomerLibBase> {
-  const monomerLibHelper = await getMonomerLibHelper();
-  const systemMonomerLib = monomerLibHelper.getMonomerLib();
-
-  const rdkit = await getRdKitModule();
-  const argLib: { [symbol: string]: Monomer } = {};
-
-  let names: string [] = [];
-  let monomers: Monomer [] = [];
-
-  for (let i = 0; i < rules.reactionRules.length; i++) {
-    try {
-      [names, monomers] = getNewMonomers(rdkit, systemMonomerLib, rules.reactionRules[i]);
-    } catch (e: any) {
-      names = [];
-      monomers = [];
-      console.error(e);
-    } finally {
-      for (let j = 0; j < names.length; j ++)
-        argLib[names[j]] = monomers[j];
-    }
-  }
-
-  const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: argLib};
-  const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData,
-    'ST-PT-reactions.' + wu.repeat(1).map(() => Math.floor((Math.random() * 36))
-      .toString(36)).take(4).toArray().join(''));
-  return overriddenMonomerLib;
-}

package/src/polytool/conversion/pt-synthetic.ts

@@ -0,0 +1,279 @@
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {Rules, RuleReaction, getMonomerPairs} from './pt-rules';
+import {InvalidReactionError, MonomerNotFoundError} from '../types';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+
+import * as grok from 'datagrok-api/grok';
+
+import wu from 'wu';
+import {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';
+import {RDModule, RDMol, RDReaction, MolList, RDReactionResult} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {HELM_REQUIRED_FIELD as REQ,
+  HELM_OPTIONAL_FIELDS as OPT, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
+
+export async function getOverriddenLibrary(rules: Rules): Promise<IMonomerLibBase> {
+  const monomerLibHelper = await getMonomerLibHelper();
+  const systemMonomerLib = monomerLibHelper.getMonomerLib();
+
+  const rdkit = await getRdKitModule();
+  const argLib: { [symbol: string]: Monomer } = {};
+
+  let names: string [] = [];
+  let monomers: Monomer [] = [];
+
+  for (let i = 0; i < rules.reactionRules.length; i++) {
+    try {
+      [names, monomers] = getNewMonomers(rdkit, systemMonomerLib, rules.reactionRules[i]);
+    } catch (e: any) {
+      names = [];
+      monomers = [];
+      console.error(e);
+    } finally {
+      for (let j = 0; j < names.length; j ++)
+        argLib[names[j]] = monomers[j];
+    }
+  }
+
+  const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: argLib};
+  const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData,
+    'ST-PT-reactions.' + wu.repeat(1).map(() => Math.floor((Math.random() * 36))
+      .toString(36)).take(4).toArray().join(''));
+  return overriddenMonomerLib;
+}
+
+export function getNewMonomers(rdkit: RDModule, mLib: IMonomerLib, rule: RuleReaction): [string[], Monomer[]] {
+  const reacSmarts = rule.reaction;
+  const monomerName = rule.name;
+  const totalLength = rule.firstMonomers.length + rule.secondMonomers.length + 1;
+  const reactionMembers = rule.reaction.split('>>');
+  const reactants = reactionMembers[0].split('.');
+
+  const monomerNames = new Array<string>(totalLength);
+  const resMonomers = new Array<Monomer>(totalLength);
+  const rawMonomers = new Array<string>(totalLength);
+
+  const mainRxn = getReactionSmirks(rdkit, reacSmarts);
+
+  const reacCutFirst = `${reactants[0]}>>[C:1]`;
+  const reacCutSecond = `${reactants[1]}>>[C:2]`;
+
+  const rxnCutFirst = getReactionSmirks(rdkit, reacCutFirst);
+  const rxnCutSecond = getReactionSmirks(rdkit, reacCutSecond);
+
+  let counter = 0;
+  for (let i = 0; i < rule.firstMonomers.length; i++) {
+    const monomer = mLib.getMonomer('PEPTIDE', rule.firstMonomers[i]);
+    if (!monomer) throw new MonomerNotFoundError('PEPTIDE', rule.firstMonomers[i]);
+
+    const sMolBlock = cutReactant(rdkit, monomer.molfile, rxnCutFirst, monomer.name);
+    rawMonomers[counter] = sMolBlock;
+    monomerNames[counter] = `${monomer.symbol}_${monomerName}`;
+    counter++;
+  }
+  for (let i = 0; i < rule.secondMonomers.length; i++) {
+    const monomer = mLib.getMonomer('PEPTIDE', rule.secondMonomers[i]);
+    if (!monomer) throw new MonomerNotFoundError('PEPTIDE', rule.secondMonomers[i]);
+
+    const sMolBlock = cutReactant(rdkit, monomer.molfile, rxnCutSecond, monomer.name);
+    rawMonomers[counter] = sMolBlock;
+    monomerNames[counter] = `${monomer.symbol}_${monomerName}`;
+    counter++;
+  }
+
+  // const monomer1 = mLib.getMonomer('PEPTIDE', rule.firstMonomers[0]);
+  // const monomer2 = mLib.getMonomer('PEPTIDE', rule.secondMonomers[0]);
+  let mol: RDMol | null = null;
+  let pMolblock = '';
+  try {
+    mol = rdkit.get_mol(reactionMembers[1]);
+    pMolblock = mol?.get_molblock();//molP?.get_v3Kmolblock();//
+  } catch (err: any) {
+    const [errMsg, _errStack] = errInfo(err);
+    grok.shell.error(`Can not assemble monomer '${monomerName}': ${errMsg}.`);
+    throw err;
+  } finally {
+    mol?.delete();
+  }
+  //pMolblock = reactionMembers[1]//cutProduct(rdkit, monomer1?.molfile, monomer2?.molfile, mainRxn, monomerName);
+  rawMonomers[counter] = pMolblock;
+  monomerNames[counter] = monomerName;
+
+  //after RDKit works
+  for (let i = 0; i < totalLength - 1; i ++)
+    rawMonomers[i] = rawMonomers[i].replace('0.0000 C   ', '0.0000 R#  ').replace('M  RGP  2', 'M  RGP  3   1   3');
+  rawMonomers[totalLength - 1] = modProduct(rawMonomers[totalLength - 1]);
+
+  for (let i = 0; i < totalLength; i ++) {
+    const isProduct = i == totalLength - 1 ? true : false;
+    const resMonomer: Monomer = {
+      [REQ.SYMBOL]: monomerNames[i],
+      [REQ.NAME]: monomerNames[i],
+      [REQ.MOLFILE]: rawMonomers[i],
+      [REQ.AUTHOR]: '',
+      [REQ.ID]: 0,
+      [REQ.RGROUPS]: getNewGroups(isProduct),
+      [REQ.SMILES]: '',
+      [REQ.POLYMER_TYPE]: 'PEPTIDE',
+      [REQ.MONOMER_TYPE]: 'Backbone',
+      [REQ.CREATE_DATE]: null,
+      // // @ts-ignore
+      // lib: {source: 'Reaction'},
+    };
+
+    resMonomer[OPT.META] = Object.assign(resMonomer[OPT.META] ?? {},
+      {'colors': {'default': {line: '#2083D5', text: '#2083D5', background: '#F2F2F5'}}});
+
+    monomerNames[i] = monomerNames[i];
+    resMonomers[i] = resMonomer;
+  }
+  mainRxn.delete();
+  rxnCutFirst.delete();
+  rxnCutSecond.delete();
+  return [monomerNames, resMonomers];
+}
+
+function modProduct(product: string): string {
+  const fullMol = product.replace('M  RAD', 'M  RGP');
+  const lines = fullMol.split('\n');
+  const natoms = Number(lines[3].substring(0, 3));
+  const nbonds = Number(lines[3].substring(3, 6));
+  const rgpShift = 4 + natoms + nbonds;
+
+  const fAtom = Number(lines[rgpShift].substring(9, 13));
+  const sAtom = Number(lines[rgpShift].substring(17, 21));
+
+  lines[rgpShift] = lines[rgpShift].substring(0, 13) + '   1' + lines[rgpShift].substring(17, 21) + '   2';
+
+  lines[3 + fAtom] = lines[3 + fAtom].substring(0, 30) + ' R#  0  0  0  0  0  0  0  0  0  0  0  0';
+  lines[3 + sAtom] = lines[3 + sAtom].substring(0, 30) + ' R#  0  0  0  0  0  0  0  0  0  0  0  0';
+
+  let res = '';
+  for (let i = 0; i < lines.length; i++)
+    res += lines[i] + '\n';
+
+  return res;
+}
+
+function cutReactant(rdkit: RDModule, reactant: string, rxn: RDReaction, monomerName: string) {
+  let mols: MolList | null = null;
+  let mol: RDMol | null = null;
+  let rctns: RDReactionResult | null = null;
+  let molP: RDMol | null = null;
+  let molBlock = '';
+
+  try {
+    mols = new rdkit.MolList();
+    mol = rdkit.get_mol(reactant);
+    mols.append(mol);
+    rctns = rxn.run_reactants(mols, 1);
+    //const size = rctns.size();
+    const element = rctns.get(0);
+    molP = element.next();
+    molBlock = molP?.get_molblock();//molP?.get_v3Kmolblock();//
+  } catch (err: any) {
+    const [errMsg, _errStack] = errInfo(err);
+    grok.shell.error(`Can not assemble monomer '${monomerName}': ${errMsg}.`);
+    throw err;
+  } finally {
+    mols?.delete();
+    mol?.delete();
+    rctns?.delete();
+    molP?.delete();
+  }
+
+  return molBlock;
+}
+
+function getReactionSmirks(rdkit: RDModule, smirks: string): RDReaction {
+  let rxn: RDReaction | null = null;
+  try {
+    rxn = rdkit.get_rxn(smirks);
+    if (!rxn) throw new InvalidReactionError(smirks);
+  } catch (err: any) {
+    rxn?.delete();
+    const [errMsg, _errStack] = errInfo(err);
+    grok.shell.error(`Can not assemble monomer '${smirks}': ${errMsg}.`);
+    throw err;
+  } finally {
+
+  }
+  return rxn;
+}
+
+function getNewGroups(isProduct: boolean): RGroup[] {
+  if (isProduct) {
+    const groups = new Array<RGroup>(2);
+    const group1: RGroup = {
+      //@ts-ignore
+      [HELM_RGROUP_FIELDS.CAP_GROUP_SMILES_UPPERCASE]: '[*:1][H]',
+      [HELM_RGROUP_FIELDS.ALTERNATE_ID]: 'R1-H',
+      [HELM_RGROUP_FIELDS.CAP_GROUP_NAME]: 'H',
+      [HELM_RGROUP_FIELDS.LABEL]: 'R1'
+    };
+    const group2: RGroup = {
+      //@ts-ignore
+      [HELM_RGROUP_FIELDS.CAP_GROUP_SMILES_UPPERCASE]: '[*:2][H]',
+      [HELM_RGROUP_FIELDS.ALTERNATE_ID]: 'R2-H',
+      [HELM_RGROUP_FIELDS.CAP_GROUP_NAME]: 'H',
+      [HELM_RGROUP_FIELDS.LABEL]: 'R2'
+    };
+
+    groups[0] = group1;
+    groups[1] = group2;
+
+    return groups;
+  } else {
+    const group: RGroup = {
+      //@ts-ignore
+      [HELM_RGROUP_FIELDS.CAP_GROUP_SMILES_UPPERCASE]: '[*:3][H]',
+      [HELM_RGROUP_FIELDS.ALTERNATE_ID]: 'R3-H',
+      [HELM_RGROUP_FIELDS.CAP_GROUP_NAME]: 'H',
+      [HELM_RGROUP_FIELDS.LABEL]: 'R3'
+    };
+
+    return [group];
+  }
+}
+
+function getSyntheticMolBlock(rdkit: RDModule, reaction: string,
+  mb1: string, mb2: string, monomerName: string): string {
+  let rxn: RDReaction | null = null;
+  let mols: MolList | null = null;
+  let mol1: RDMol | null = null;
+  let mol2: RDMol | null = null;
+  let rctns: RDReactionResult | null = null;
+  let molP: RDMol | null = null;
+  let molBlock = '';
+
+  try {
+    rxn = rdkit.get_rxn(reaction);
+    if (!rxn) throw new InvalidReactionError(reaction);
+    mols = new rdkit.MolList();
+    mol1 = rdkit.get_mol(mb1!);
+    mol2 = rdkit.get_mol(mb2!);
+    mols.append(mol1!);
+    mols.append(mol2!);
+
+    rctns = rxn.run_reactants(mols, 1);
+    //const size = rctns.size();
+    const element = rctns.get(0);
+
+    molP = element.next();
+    molBlock = molP?.get_molblock();//molP?.get_v3Kmolblock();//
+  } catch (err: any) {
+    const [errMsg, _errStack] = errInfo(err);
+    grok.shell.error(`Can not assemble monomer '${monomerName}': ${errMsg}.`);
+    throw err;
+  } finally {
+    rxn?.delete();
+    mols?.delete();
+    mol1?.delete();
+    mol2?.delete();
+    rctns?.delete();
+    molP?.delete();
+  }
+
+  return molBlock;
+}

package/src/polytool/conversion/pt-tools-helmmol.ts

@@ -0,0 +1,114 @@
+import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {Atom, IHelmBio, HelmMol, HelmType, JSDraw2ModuleType, OrgType} from '@datagrok-libraries/bio/src/helm/types';
+import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {Linkage} from './pt-misc';
+
+declare const JSDraw2: JSDraw2ModuleType;
+declare const org: OrgType;
+
+
+export type PtBio = IHelmBio & { i: number, j: number };
+type PtAtom = Atom<HelmType, PtBio>
+
+export function getHelmMol(linkages: Linkage[], mainFragments: string[][], helmHelper: IHelmHelper): HelmMol {
+  const resHwe = helmHelper.createHelmWebEditor();
+  const resMol = resHwe.editor.m;
+
+  let counter = 0;
+  const p = new JSDraw2.Point(0, 0);
+  for (let i = 0; i < mainFragments.length; i++) {
+    for (let j = 0; j < mainFragments[i].length; j++) {
+      if (!!mainFragments[i][j]) {
+        const elem = mainFragments[i][j];
+        const bio: PtBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+        const atom = new JSDraw2.Atom<HelmType, IHelmBio>(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, IHelmBio>(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
+    }
+  }
+
+  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, IHelmBio>(atom1, atom2);
+    bond.r1 = linkages[i].fR;
+    bond.r2 = linkages[i].sR;
+    resMol.addBond(bond);
+  }
+  return resMol;
+}
+
+export function helmMolToNotation(mol: HelmMol): string {
+  const atoms = mol.atoms;
+  const bonds = mol.bonds;
+  const chains: number[] = [];
+  const specialBonds: number[] = [];
+  for (let i = 0; i < bonds.length!; i++) {
+    //@ts-ignore
+    if (bonds[i].a1.bio.i !== bonds[i].a2.bio.i)
+      specialBonds.push(i);
+  }
+
+  for (let i = 0; i < atoms.length!; i++) {
+    //@ts-ignore
+    const atomChain = atoms[i].bio?.i;
+    if (atomChain + 1 > chains.length)
+      chains.push(1);
+    else
+      chains[atomChain]++;
+  }
+
+  const simpleChains: string[][] = new Array(chains.length);
+  let counter = 0;
+  for (let i = 0; i < chains.length!; i++) {
+    const simpleChain: string[] = new Array(chains[i]);
+    for (let j = 0; j < chains[i]; j++) {
+      simpleChain[j] = atoms[counter].elem;
+      counter++;
+    }
+
+    simpleChains[i] = simpleChain;
+  }
+
+  let res = '';
+  for (let i = 0; i < simpleChains.length; i++) {
+    let chainAdd = '';
+
+    for (let j = 0; j < simpleChains[i].length; j++)
+      chainAdd += `${j == 0 ? '' : '-'}${simpleChains[i][j]}`;
+
+    if (i !== 0) {
+      const rxp = /(\(.\d+\))/;
+      const match = chainAdd.match(rxp);
+      chainAdd = chainAdd.replace(match?.[0]!, '');
+      const group = match ? match?.[0]! : '';
+      chainAdd = `${group}{${chainAdd}}`;
+    } else {
+      if (simpleChains.length > 1) {
+        //@ts-ignore
+        const firstAtomLinks = bonds[specialBonds[0]].a1.bio.i == 0 && bonds[specialBonds[0]].a1.bio.j == 0;
+        //@ts-ignore
+        const secondAtomLinks = bonds[specialBonds[0]].a2.bio.i == 1 && bonds[specialBonds[0]].a1.bio.j == 0;
+        if (firstAtomLinks && secondAtomLinks)
+          chainAdd += '-';
+      }
+    }
+
+    res += chainAdd;
+  }
+
+  return res;
+}