@datagrok/bio 2.12.11 → 2.12.13

package/src/utils/helm-to-molfile/converter/mol-bonds.ts

@@ -0,0 +1,56 @@
+import {PositionInBonds} from './types';
+
+export abstract class MolfileBonds {
+  protected bondedAtomPairs: number[][] = [];
+  protected rawBondLines: string[] = [];
+
+  /** Get bond lines with new values for bonded atoms  */
+  abstract getBondLines(): string[];
+
+  get bondedAtoms(): number[][] {
+    return this.bondedAtomPairs;
+  }
+
+  deleteBondLines(indices: number[]): void {
+    this.rawBondLines = this.rawBondLines.filter((_, idx) => !indices.includes(idx));
+    this.bondedAtomPairs = this.bondedAtomPairs.filter((_, idx) => !indices.includes(idx));
+  }
+
+  /** Atom id starts from 1  */
+  getPositionsInBonds(atomId: number): PositionInBonds[] {
+    const positions: PositionInBonds[] = [];
+    this.bondedAtomPairs.forEach((bondedPair, bondLineIdx) => {
+      bondedPair.forEach((atom, nodeIdx) => {
+        if (atom === atomId)
+          positions.push({bondLineIdx, nodeIdx});
+      });
+    });
+    return positions;
+  }
+
+  replacePositionsInBondsByDummy(positions: PositionInBonds[], dummy?: number): void {
+    if (dummy === undefined)
+      dummy = -1;
+    positions.forEach((position) => {
+      const {bondLineIdx, nodeIdx} = position;
+      this.bondedAtomPairs[bondLineIdx][nodeIdx] = dummy!;
+    });
+  }
+
+  removeAtomIdFromBonds(atomId: number): void {
+    this.bondedAtomPairs = this.bondedAtomPairs.map((bondedPair) => {
+      return bondedPair.map((id) => {
+        if (id > atomId)
+          return id - 1;
+        return id;
+      });
+    });
+  }
+
+  shift(shift: number): void {
+    this.bondedAtomPairs = this.bondedAtomPairs.map((bondedPair) => {
+      return bondedPair.map((id) => id + shift);
+    });
+  }
+}
+

package/src/utils/helm-to-molfile/converter/mol-wrapper-factory.ts

@@ -0,0 +1,16 @@
+import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
+import {MolfileWrapper} from './mol-wrapper';
+import {MolfileV2KWrapper} from './mol-wrapper-v2k';
+import {MolfileV3KWrapper} from './mol-wrapper-v3k';
+
+export class MolfileWrapperFactory {
+  static getInstance(molfile: string, monomerSymbol: string): MolfileWrapper {
+    if (MolfileHandler.isMolfileV2K(molfile))
+      return new MolfileV2KWrapper(molfile, monomerSymbol) as MolfileWrapper;
+    else if (MolfileHandler.isMolfileV3K(molfile))
+      return new MolfileV3KWrapper(molfile, monomerSymbol) as MolfileWrapper;
+    else
+      throw new Error('Unsupported molfile version');
+  }
+}
+

package/src/utils/helm-to-molfile/converter/mol-wrapper-old.ts

@@ -0,0 +1,100 @@
+// import {MolfileAtoms} from './mol-atoms';
+// import {MolfileBonds} from './mol-bonds';
+// import {RGroupHandler} from './r-group-handler';
+
+// export class MolfileWrapper {
+//   constructor(molfileV2K: string, private monomerSymbol: string) {
+//     const lines = molfileV2K.split('\n');
+
+//     // TODO: port to consts
+//     const atomCountIdx = {begin: 0, end: 3};
+//     const bondCountIdx = {begin: 3, end: 6};
+//     const countsLineIdx = 3;
+//     const atomBlockIdx = 4;
+
+//     const atomCount = parseInt(lines[countsLineIdx].substring(atomCountIdx.begin, atomCountIdx.end));
+//     const bondCount = parseInt(lines[countsLineIdx].substring(bondCountIdx.begin, bondCountIdx.end));
+
+//     const atomLines = lines.slice(atomBlockIdx, atomBlockIdx + atomCount);
+//     this.atoms = new MolfileAtoms(atomLines);
+
+//     const bondLines = lines.slice(atomBlockIdx + atomCount, atomBlockIdx + atomCount + bondCount);
+//     this.bonds = new MolfileBonds(bondLines);
+
+//     this.rGroups = new RGroupHandler(lines, this.atoms, this.bonds);
+
+//     this.shiftMonomerToDefaultPosition();
+//   }
+
+//   private atoms: MolfileAtoms;
+//   private bonds: MolfileBonds;
+//   private rGroups: RGroupHandler;
+
+//   deleteBondLineWithSpecifiedRGroup(rGroupId: number): void {
+//     this.rGroups.deleteBondLineWithSpecifiedRGroup(rGroupId);
+//   }
+
+//   shiftCoordinates(shift: {x: number, y: number}): void {
+//     this.atoms.shift(shift);
+//   }
+
+//   rotateCoordinates(angle: number): void {
+//     this.atoms.rotate(angle);
+//   }
+
+//   getBondLines(): string[] {
+//     return this.bonds.getBondLines();
+//   }
+
+//   getAtomLines(): string[] {
+//     return this.atoms.atomLines;
+//   }
+
+//   removeRGroups(rGroupIds: number[]): void {
+//     this.rGroups.removeRGroups(rGroupIds);
+//   }
+
+//   replaceRGroupWithAttachmentAtom(rGroupId: number, externalAtom: number): void {
+//     this.rGroups.replaceRGroupWithAttachmentAtom(rGroupId, externalAtom);
+//   }
+
+//   getAttachmentAtomByRGroupId(rgroupId: number): number {
+//     return this.rGroups.getAttachmentAtomIdByRGroupId(rgroupId);
+//   }
+
+//   private shiftR1GroupToOrigin(): void {
+//     const r1Idx = this.rGroups.getAtomicIdx(1);
+//     if (r1Idx === null)
+//       throw new Error(`Cannot find R1 group for monomer ${this.monomerSymbol}`);
+//     const {x, y} = this.atoms.atomCoordinates[r1Idx];
+//     this.atoms.shift({x: -x, y: -y});
+//   }
+
+//   private alignR2AlongX(): void {
+//     const r2Idx = this.rGroups.getAtomicIdx(2);
+//     if (r2Idx === null)
+//       throw new Error(`Cannot find R2 group for monomer ${this.monomerSymbol}`);
+//     const r2Coordinates = this.atoms.atomCoordinates[r2Idx];
+//     const tan = r2Coordinates.y / r2Coordinates.x;
+//     const angle = Math.atan(tan);
+//     if (isNaN(angle))
+//       throw new Error(`Cannot calculate angle for R2 group for monomer ${this.monomerSymbol}`);
+//     this.rotateCoordinates(-angle);
+//   }
+
+//   private shiftMonomerToDefaultPosition(): void {
+//     this.shiftR1GroupToOrigin();
+//     const r2Idx = this.rGroups.getAtomicIdx(2);
+//     if (r2Idx !== null)
+//       this.alignR2AlongX();
+//   }
+
+//   shiftBonds(shift: number): void {
+//     this.bonds.shift(shift);
+//   }
+
+//   capRGroups(capGroupElements: string[]): void {
+//     this.rGroups.capRGroups(capGroupElements);
+//   }
+// }
+

package/src/utils/helm-to-molfile/converter/mol-wrapper-v2k.ts

@@ -0,0 +1,21 @@
+import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
+import {MolfileWrapper} from './mol-wrapper';
+import {RGroupHandler} from './r-group-handler';
+import {MolfileAtomsV2K} from './mol-atoms-v2k';
+import {MolfileBondsV2K} from './mol-bonds-v2k';
+
+export class MolfileV2KWrapper extends MolfileWrapper {
+  constructor(
+    molfileV2K: string, monomerSymbol: string
+  ) {
+    super(monomerSymbol);
+    const molfileHandler = MolfileHandler.getInstance(molfileV2K);
+
+    this.atoms = new MolfileAtomsV2K(molfileHandler);
+    this.bonds = new MolfileBondsV2K(molfileHandler);
+    this.rGroups = new RGroupHandler(molfileHandler, this.atoms, this.bonds);
+
+    this.shiftMonomerToDefaultPosition();
+  }
+}
+

package/src/utils/helm-to-molfile/converter/mol-wrapper-v3k.ts

@@ -0,0 +1,21 @@
+import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
+import {MolfileWrapper} from './mol-wrapper';
+import {RGroupHandler} from './r-group-handler';
+import {MolfileAtomsV3K} from './mol-atoms-v3k';
+import {MolfileBondsV3K} from './mol-bonds-v3k';
+
+export class MolfileV3KWrapper extends MolfileWrapper {
+  constructor(
+    molfileV3K: string, monomerSymbol: string
+  ) {
+    super(monomerSymbol);
+    const molfileHandler = MolfileHandler.getInstance(molfileV3K);
+
+    this.atoms = new MolfileAtomsV3K(molfileHandler);
+    this.bonds = new MolfileBondsV3K(molfileHandler);
+    this.rGroups = new RGroupHandler(molfileHandler, this.atoms, this.bonds);
+
+    this.shiftMonomerToDefaultPosition();
+  }
+}
+

package/src/utils/helm-to-molfile/converter/mol-wrapper.ts

@@ -0,0 +1,79 @@
+import {MolfileAtoms} from './mol-atoms';
+import {MolfileBonds} from './mol-bonds';
+import {RGroupHandler} from './r-group-handler';
+
+export abstract class MolfileWrapper {
+  constructor(protected monomerSymbol: string) { }
+
+  protected atoms: MolfileAtoms;
+  protected bonds: MolfileBonds;
+  protected rGroups: RGroupHandler;
+
+  protected shiftR1GroupToOrigin(): void {
+    const r1Idx = this.rGroups.getAtomicIdx(1);
+    if (r1Idx === null)
+      throw new Error(`Cannot find R1 group for monomer ${this.monomerSymbol}`);
+    const {x, y} = this.atoms.atomCoordinates[r1Idx];
+    this.atoms.shift({x: -x, y: -y});
+  }
+
+  protected alignR2AlongX(): void {
+    const r2Idx = this.rGroups.getAtomicIdx(2);
+    if (r2Idx === null)
+      throw new Error(`Cannot find R2 group for monomer ${this.monomerSymbol}`);
+    const r2Coordinates = this.atoms.atomCoordinates[r2Idx];
+    const tan = r2Coordinates.y / r2Coordinates.x;
+    const angle = Math.atan(tan);
+    if (isNaN(angle))
+      throw new Error(`Cannot calculate angle for R2 group for monomer ${this.monomerSymbol}`);
+    this.rotateCoordinates(-angle);
+  }
+
+  protected shiftMonomerToDefaultPosition(): void {
+    this.shiftR1GroupToOrigin();
+    const r2Idx = this.rGroups.getAtomicIdx(2);
+    if (r2Idx !== null)
+      this.alignR2AlongX();
+  }
+
+  deleteBondLineWithSpecifiedRGroup(rGroupId: number): void {
+    this.rGroups.deleteBondLineWithSpecifiedRGroup(rGroupId);
+  }
+
+  shiftCoordinates(shift: {x: number, y: number}): void {
+    this.atoms.shift(shift);
+  }
+
+  rotateCoordinates(angle: number): void {
+    this.atoms.rotate(angle);
+  }
+
+  getBondLines(): string[] {
+    return this.bonds.getBondLines();
+  }
+
+  getAtomLines(): string[] {
+    return this.atoms.atomLines;
+  }
+
+  removeRGroups(rGroupIds: number[]): void {
+    this.rGroups.removeRGroups(rGroupIds);
+  }
+
+  replaceRGroupWithAttachmentAtom(rGroupId: number, externalAtom: number): void {
+    this.rGroups.replaceRGroupWithAttachmentAtom(rGroupId, externalAtom);
+  }
+
+  getAttachmentAtomByRGroupId(rgroupId: number): number {
+    return this.rGroups.getAttachmentAtomIdByRGroupId(rgroupId);
+  }
+
+  shiftBonds(shift: number): void {
+    this.bonds.shift(shift);
+  }
+
+  capRGroups(capGroupElements: string[]): void {
+    this.rGroups.capRGroups(capGroupElements);
+  }
+}
+

package/src/utils/helm-to-molfile/converter/monomer-wrapper.ts

@@ -0,0 +1,103 @@
+import {Monomer} from '@datagrok-libraries/bio/src/types';
+import {HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {MonomerLibManager} from '../../monomer-lib/lib-manager';
+import {Helm} from './helm';
+import {MolfileWrapper} from './mol-wrapper';
+import {MolfileWrapperFactory} from './mol-wrapper-factory';
+import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
+
+export class MonomerWrapper {
+  private molfileWrapper: MolfileWrapper;
+  private capGroupElements: string[] = [];
+
+  constructor(
+    private monomerSymbol: string,
+    private monomerIdx: number,
+    private helm: Helm,
+    shift: {x: number, y: number},
+    rdKitModule: RDModule
+  ) {
+    const libraryMonomerObject = this.getLibraryMonomerObject();
+
+    let molfile = libraryMonomerObject.molfile;
+    if (MolfileHandler.isMolfileV2K(molfile))
+      molfile = this.convertMolfileToV3KFormat(molfile, rdKitModule);
+
+    this.molfileWrapper = MolfileWrapperFactory.getInstance(molfile, monomerSymbol);
+    this.capGroupElements = this.getCapGroupElements(libraryMonomerObject);
+
+    if (helm.bondedRGroupsMap.has(monomerIdx))
+      this.removeRGroups(helm.bondedRGroupsMap.get(monomerIdx)!);
+    this.capRemainingRGroups();
+
+    this.shiftCoordinates(shift);
+  }
+
+  private convertMolfileToV3KFormat(molfileV2K: string, rdKitModule: RDModule): string {
+    return rdKitModule.get_mol(molfileV2K, JSON.stringify({mergeQueryHs: true})).get_v3Kmolblock();
+  }
+
+  private getLibraryMonomerObject(): Monomer {
+    const polymerType = this.helm.getPolymerTypeByMonomerIdx(this.monomerIdx);
+    const monomerLib = MonomerLibManager.instance.getBioLib();
+    const monomer = monomerLib.getMonomer(polymerType, this.monomerSymbol);
+    if (!monomer)
+      throw new Error(`Monomer ${this.monomerSymbol} is not found in the library`);
+    return monomer;
+  }
+
+  private getCapGroupElements(
+    libraryMonomerObject: Monomer
+  ): string[] {
+    const rgroups = libraryMonomerObject.rgroups;
+    const result = rgroups.map((rgroup) => {
+      const smiles = rgroup[HELM_RGROUP_FIELDS.CAP_GROUP_SMILES] ||
+        // WARNING: ignore because both key variants coexist in HELM Core Library!
+        // @ts-ignore
+        rgroup[HELM_RGROUP_FIELDS.CAP_GROUP_SMILES_UPPERCASE];
+      // extract the element symbol
+      return smiles.replace(/(\[|\]|\*|:|\d)/g, '');
+    });
+
+    return result;
+  }
+
+  private shiftCoordinates(shift: {x: number, y: number}): void {
+    this.molfileWrapper.shiftCoordinates(shift);
+  }
+
+  getAtomLines(): string[] {
+    return this.molfileWrapper.getAtomLines();
+  }
+
+  getBondLines(): string[] {
+    return this.molfileWrapper.getBondLines();
+  }
+
+  private removeRGroups(rGroupIds: number[]): void {
+    this.molfileWrapper.removeRGroups(rGroupIds);
+  }
+
+  private capRemainingRGroups(): void {
+    this.molfileWrapper.capRGroups(this.capGroupElements);
+  }
+
+  replaceRGroupWithAttachmentAtom(rGroupId: number, attachmentAtomIdx: number): void {
+    this.molfileWrapper.replaceRGroupWithAttachmentAtom(rGroupId, attachmentAtomIdx);
+  };
+
+  getAttachmentAtomByRGroupId(rGroupId: number): number {
+    const attachmentAtom = this.molfileWrapper.getAttachmentAtomByRGroupId(rGroupId);
+    return attachmentAtom;
+  }
+
+  deleteBondLineWithSpecifiedRGroup(rGroupId: number): void {
+    this.molfileWrapper.deleteBondLineWithSpecifiedRGroup(rGroupId);
+  }
+
+  shiftBonds(shift: number): void {
+    this.molfileWrapper.shiftBonds(shift);
+  }
+}
+

package/src/utils/helm-to-molfile/converter/polymer.ts

@@ -0,0 +1,99 @@
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {V3K_CONST} from '@datagrok-libraries/chem-meta/src/formats/molfile-const';
+import {Helm} from './helm';
+import {MonomerWrapper} from './monomer-wrapper';
+
+export class Polymer {
+  constructor(helmString: string, private rdKitModule: RDModule) {
+    this.helm = new Helm(helmString);
+  }
+
+  private monomerWrappers: MonomerWrapper[] = [];
+  private helm: Helm;
+
+  addMonomer(
+    monomerSymbol: string,
+    monomerIdx: number,
+    shift: {x: number, y: number},
+  ): void {
+    const monomerWrapper = new MonomerWrapper(monomerSymbol, monomerIdx, this.helm, shift, this.rdKitModule);
+
+    this.monomerWrappers.push(monomerWrapper);
+  }
+
+  private getAtomNumberShifts(): number[] {
+    const atomNumberShifts: number[] = [];
+    let shift = 0;
+    this.monomerWrappers.forEach((monomerWrapper) => {
+      atomNumberShifts.push(shift);
+      shift += monomerWrapper.getAtomLines().length;
+    });
+    return atomNumberShifts;
+  }
+
+  private restoreBondsBetweenMonomers(): void {
+    this.helm.bondData.forEach((bond) => {
+      const monomerIdx = bond.map((bondPart) => bondPart.monomerIdx);
+      const rGroupId = bond.map((bondPart) => bondPart.rGroupId);
+      const monomer = monomerIdx.map((idx) => this.monomerWrappers[idx]);
+
+      const attachmentAtom = monomer[1].getAttachmentAtomByRGroupId(rGroupId[1]);
+      monomer[0].replaceRGroupWithAttachmentAtom(rGroupId[0], attachmentAtom);
+      monomer[1].deleteBondLineWithSpecifiedRGroup(rGroupId[1]);
+    });
+  }
+
+  compileToMolfile(): string {
+    const atomLines: string[] = [];
+    const bondLines: string[] = [];
+
+    const atomNumberShifts = this.getAtomNumberShifts();
+    this.monomerWrappers.forEach((monomerWrapper, idx) => {
+      monomerWrapper.shiftBonds(atomNumberShifts[idx]);
+    });
+
+    this.restoreBondsBetweenMonomers();
+
+    this.monomerWrappers.forEach((monomerWrapper) => {
+      atomLines.push(...monomerWrapper.getAtomLines());
+      bondLines.push(...monomerWrapper.getBondLines());
+    });
+
+    const atomCount = atomLines.length;
+    const bondCount = bondLines.length;
+
+    const header = this.getV3KHeader(atomCount, bondCount);
+    const atomBlock = this.getV3KAtomBlock(atomLines);
+    const bondBlock = this.getV3KBondBlock(bondLines);
+    const molfileEnd = V3K_CONST.END_CTAB + '\n' + V3K_CONST.END;
+    const blockList = [header, atomBlock, bondBlock, molfileEnd];
+    const molfile = blockList.join('\n');
+    return molfile;
+  }
+
+  private getV3KHeader(atomCount: number, bondCount: number): string {
+    const countsLine = `${V3K_CONST.COUNTS_LINE_START}${atomCount} ${bondCount}${V3K_CONST.COUNTS_LINE_DUMMY_END}`;
+    return `${V3K_CONST.DUMMY_HEADER}\n${V3K_CONST.BEGIN_CTAB}\n${countsLine}`;
+  }
+
+  private getV3KAtomBlock(atomLines: string[]): string {
+    const regex = /^(M  V30 )(\d+)( .*)$/;
+    const newAtomLines = atomLines.map((line, idx) => {
+      const atomIndex = idx + 1;
+      return line.replace(regex, (match, p1, p2, p3) => { return p1 + atomIndex + p3; });
+    });
+
+    const atomBlock = [V3K_CONST.BEGIN_ATOM_BLOCK, ...newAtomLines, V3K_CONST.END_ATOM_BLOCK];
+    return atomBlock.join('\n');
+  }
+
+  private getV3KBondBlock(bondLines: string[]): string {
+    const regex = /^(M  V30 )(\d+)( .*)$/;
+    const newBondLines = bondLines.map((line, idx) => {
+      const atomIndex = idx + 1;
+      return line.replace(regex, (match, p1, p2, p3) => { return p1 + atomIndex + p3; });
+    });
+    const bondBlock = [V3K_CONST.BEGIN_BOND_BLOCK, ...newBondLines, V3K_CONST.END_BOND_BLOCK];
+    return bondBlock.join('\n');
+  }
+}

package/src/utils/helm-to-molfile/converter/position-handler.ts

@@ -0,0 +1,23 @@
+import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
+import {MolfileHandlerBase} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler-base';
+
+/** Extracts positions of vertices from pseudo-molfile (with
+ * monomers being the vertices) generated by HELM Web Editor  */
+export class GlobalMonomerPositionHandler {
+  constructor(helmCoordinatesPseudoMolfile: string) {
+    this.molfileHandler = MolfileHandler.getInstance(helmCoordinatesPseudoMolfile);
+  }
+
+  private molfileHandler: MolfileHandlerBase;
+
+  get monomerSymbols(): string[] {
+    return this.molfileHandler.atomTypes;
+  }
+
+  getMonomerShifts(monomerIdx: number): {x: number, y: number} {
+    const x = this.molfileHandler.x[monomerIdx];
+    const y = this.molfileHandler.y[monomerIdx];
+    return {x, y};
+  }
+}
+

package/src/utils/helm-to-molfile/converter/r-group-handler.ts

@@ -0,0 +1,122 @@
+import {MolfileHandlerBase} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler-base';
+import {HYDROGEN_SYMBOL} from './const';
+import {MolfileAtoms} from './mol-atoms';
+import {MolfileBonds} from './mol-bonds';
+import {PositionInBonds} from './types';
+
+
+export class RGroupHandler {
+  constructor(molfileHandler: MolfileHandlerBase, private atoms: MolfileAtoms, private bonds: MolfileBonds) {
+    this.rGroupIdToAtomicIndexMap = molfileHandler.getRGroupIdToAtomicIdxMap();
+  }
+
+  /** Relates R group id (starting from 1) to its atomic index within the
+   * molfile  */
+  rGroupIdToAtomicIndexMap: Map<number, number>;
+
+  /** Maps R group id (starting from 1) to its position in the bond block  */
+  private rGroupBondPositionMap = new Map<number, PositionInBonds>();
+
+  getAtomicIdx(rGroupId: number): number | null {
+    const atomicIdx = this.rGroupIdToAtomicIndexMap.get(rGroupId);
+    return atomicIdx === undefined ? null : atomicIdx;
+  }
+
+  private removeRGroupsFromAtomBlock(rGroupIds: number[]): void {
+    rGroupIds.forEach((rgroupId) => {
+      const atomicIdx = this.rGroupIdToAtomicIndexMap.get(rgroupId);
+      if (atomicIdx === undefined)
+        throw new Error(`Cannot find atomic index for R group ${rgroupId}`);
+    });
+
+    const rGroupAtomicIndices = Array.from(this.rGroupIdToAtomicIndexMap.entries()).filter(
+      ([rGroupId, _]) => rGroupIds.includes(rGroupId)
+    ).map(([_, atomicIdx]) => atomicIdx);
+    this.atoms.deleteAtoms(rGroupAtomicIndices);
+  }
+
+  removeRGroups(rGroupIds: number[]): void {
+    this.removeRGroupsFromAtomBlock(rGroupIds);
+
+    rGroupIds.forEach((rGroupId) => {
+      const dummyPosition = this.replaceRGroupInBondsByDummy(rGroupId);
+      this.rGroupBondPositionMap.set(rGroupId, dummyPosition);
+    });
+  }
+
+  /** Replace RGroups by -1, update associated maps, and return the position in
+   * bond block */
+  private replaceRGroupInBondsByDummy(rGroupId: number): PositionInBonds {
+    const rGroupAtomicIdx = this.rGroupIdToAtomicIndexMap.get(rGroupId)!;
+
+    if (this.rGroupBondPositionMap.has(rGroupId))
+      throw new Error(`R group ${rGroupId} is already handled`);
+
+    const positions = this.bonds.getPositionsInBonds(rGroupAtomicIdx + 1);
+    if (positions.length === 0)
+      throw new Error(`Cannot find position for R group ${rGroupId}`);
+    if (positions.length > 1)
+      throw new Error(`More than one position for R group ${rGroupId}`);
+
+    const rGroupPosition = positions[0];
+
+    this.bonds.replacePositionsInBondsByDummy([rGroupPosition]);
+    this.bonds.removeAtomIdFromBonds(rGroupAtomicIdx + 1);
+    this.removeRGroupFromAtomicIdxMap(rGroupId, rGroupAtomicIdx);
+
+    return rGroupPosition;
+  }
+
+  private removeRGroupFromAtomicIdxMap(deletedId: number, deletedAtomicIdx: number): void {
+    this.rGroupIdToAtomicIndexMap.delete(deletedId);
+    for (const [rGroupId, rGroupAtomicIdx] of this.rGroupIdToAtomicIndexMap) {
+      if (rGroupAtomicIdx > deletedAtomicIdx)
+        this.rGroupIdToAtomicIndexMap.set(rGroupId, rGroupAtomicIdx - 1);
+    }
+  }
+
+  deleteBondLineWithSpecifiedRGroup(rGroupId: number): void {
+    const position = this.rGroupBondPositionMap.get(rGroupId);
+    if (!position)
+      throw new Error(`Cannot find position for R group ${rGroupId}`);
+    const {bondLineIdx} = position;
+    this.bonds.deleteBondLines([bondLineIdx]);
+    this.rGroupBondPositionMap.delete(rGroupId);
+    this.rGroupIdToAtomicIndexMap.delete(rGroupId);
+    // update values of other positions
+    this.rGroupBondPositionMap.forEach((position) => {
+      if (position.bondLineIdx > bondLineIdx)
+        position.bondLineIdx -= 1;
+    });
+  }
+
+  replaceRGroupWithAttachmentAtom(rGroupId: number, externalAtom: number): void {
+    const position = this.rGroupBondPositionMap.get(rGroupId);
+    if (!position)
+      throw new Error(`Cannot find position for R group ${rGroupId}`);
+    const {bondLineIdx, nodeIdx} = position;
+    this.bonds.bondedAtoms[bondLineIdx][nodeIdx] = externalAtom;
+  }
+
+  /** Atom id is molfile id starting from 1  */
+  getAttachmentAtomIdByRGroupId(rgroupId: number): number {
+    const position = this.rGroupBondPositionMap.get(rgroupId);
+    if (!position)
+      throw new Error(`Cannot find position for R group ${rgroupId}`);
+    const {bondLineIdx, nodeIdx} = position;
+    return this.bonds.bondedAtoms[bondLineIdx][(nodeIdx + 1) % 2];
+  }
+
+  /** WARNING: capping RGroups and deletion of the bonded ones don't commute */
+  capRGroups(capGroupElements: string[]): void {
+    this.rGroupIdToAtomicIndexMap.forEach((atomicIdx, rGroupId) => {
+      const element = capGroupElements[rGroupId - 1];
+      if (element === HYDROGEN_SYMBOL) {
+        this.removeRGroups([rGroupId]);
+        this.deleteBondLineWithSpecifiedRGroup(rGroupId);
+      } else
+        this.atoms.replaceRGroupSymbolByElement(atomicIdx, element);
+    });
+  }
+}
+