@datagrok/sequence-translator 1.4.10 → 1.5.0

package/files/polytool-rules/rules_example.json

@@ -1,44 +1,41 @@
-[
-  {
-    "type": "link",
-    "code": "1",
-    "monomericSubstitution": {
-      "firstMonomer": "C",
-      "secondMonomer": "C",
-      "firstLinkingGroup": "3",
-      "secondLinkingGroup": "3",
-      "firstSubstitution": "C",
-      "secondSubstitution": "C"
-    }
-  },
-  {
-    "type": "link",
-    "code": "2",
-    "monomericSubstitution": {
-      "firstMonomer": "NH2",
-      "secondMonomer": "D",
+{
+  "homodimerCode": "#2",
+  "heterodimerCode": "$2",
+  "linkRules": [
+    {
+      "firstMonomers": [
+        "NH2"
+      ],
+      "secondMonomers": [
+        "D"
+      ],
       "firstLinkingGroup": "2",
       "secondLinkingGroup": "3",
-      "firstSubstitution": "NH2",
-      "secondSubstitution": "D"
+      "code": "2"
+    },
+    {
+      "firstMonomers": [
+        "C"
+      ],
+      "secondMonomers": [
+        "C"
+      ],
+      "firstLinkingGroup": "3",
+      "secondLinkingGroup": "3",
+      "code": "1"
     }
-  },
-  {
-    "type": "reaction",
-    "code": "4",
-    "monomericSubstitution": {
-      "firstMonomer": "azG",
-      "secondMonomer": "aG",
+  ],
+  "reactionRules": [
+    {
+      "code": 4,
+      "firstMonomers": [
+        "azG"
+      ],
+      "secondMonomers": [
+        "aG"
+      ],
       "reaction": "[C:1]N=[N+]=[N-].[C:2]C#C>>[C:1]N1-N=NC=C1[C:2]",
       "name": "GGaz"
     }
-  },
-  {
-    "type": "fragmentDuplication",
-    "code": "#3"
-  },
-  {
-    "type": "differentFragments",
-    "code": "$3"
-  }
-]
+  ]
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.4.10",
+  "version": "1.5.0",
   "author": {
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"

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

@@ -1,10 +1,10 @@
-import {Atom, IHelmBio, HelmMol, HelmType, JSDraw2ModuleType, OrgType,} from '@datagrok-libraries/bio/src/helm/types';
-import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {Atom, IHelmBio, HelmMol, HelmType, JSDraw2ModuleType, OrgType} from '@datagrok-libraries/bio/src/helm/types';
+import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
 import {cleanupHelmSymbol} from '@datagrok-libraries/bio/src/helm/utils';
 
 import {getOuterIdx, getInnerIdx} from './pt-misc';
-import {Rules, RuleLink, RuleReaction} from '../pt-rules';
+import {Rules, RuleLink, RuleReaction, getMonomerPairs} from './pt-rules';
 
 declare const JSDraw2: JSDraw2ModuleType;
 declare const org: OrgType;
@@ -523,7 +523,7 @@ export class Chain {
 
   protected static getLinkedPositions(monomers: string[], rules: RuleLink[] | RuleReaction []):
     [number, number, number][] {
-    const result: [number, number, number][] = new Array<[number, number, number]>(rules.length);
+    const result: [number, number, number][] = [];
 
     for (let i = 0; i < rules.length; i++) {
       let firstFound = false;
@@ -532,42 +532,78 @@ export class Chain {
       let firstEntryIndex = -1;
       let secondEntryIndex = -1;
       const add = `(${rules[i].code})`;
-      for (let j = 0; j < monomers.length; j++) {
-        if (monomers[j].includes(add)) {
-          if (firstFound) {
-            if (firstIsFirst && monomers[j] == rules[i].secondMonomer + add) {
-              secondFound = true;
-              secondEntryIndex = j;
-              break;
-            } else if (!firstIsFirst && monomers[j] == rules[i].firstMonomer + add) {
-              secondFound = true;
-              secondEntryIndex = j;
-              break;
-            } else {
-              continue;
+
+      const [firstMonomers, secondMonomers] = getMonomerPairs(rules[i]);
+
+      if (firstMonomers.length > 0) {
+        for (let j = 0; j < firstMonomers.length; j++) {
+          for (let k = 0; k < monomers.length; k++) {
+            if (monomers[k].includes(add)) {
+              if (firstFound) {
+                if (firstIsFirst && monomers[k] == secondMonomers[j] + add) {
+                  secondFound = true;
+                  secondEntryIndex = k;
+                  break;
+                } else if (!firstIsFirst && monomers[k] == firstMonomers[j] + add) {
+                  secondFound = true;
+                  secondEntryIndex = k;
+                  break;
+                } else {
+                  continue;
+                }
+              } else {
+                if (monomers[k] == firstMonomers[j] + add) {
+                  firstFound = true;
+                  firstIsFirst = true;
+                  firstEntryIndex = k;
+                } else if (monomers[k] == secondMonomers[j] + add) {
+                  firstFound = true;
+                  firstIsFirst = false;
+                  firstEntryIndex = k;
+                } else {
+                  continue;
+                }
+              }
             }
-          } else {
-            if (monomers[j] == rules[i].firstMonomer + add) {
+          }
+
+          if (!(firstFound && secondFound))
+            continue;
+          else if (firstIsFirst)
+            result.push([firstEntryIndex, secondEntryIndex, i]);
+          else
+            result.push([secondEntryIndex, firstEntryIndex, i]);
+        }
+      } else {
+        for (let k = 0; k < monomers.length; k++) {
+          if (monomers[k].includes(add)) {
+            if (firstFound) {
+              if (firstIsFirst && monomers[k]) {
+                secondFound = true;
+                secondEntryIndex = k;
+                break;
+              } else if (!firstIsFirst && monomers[k]) {
+                secondFound = true;
+                secondEntryIndex = k;
+                break;
+              } else {
+                continue;
+              }
+            } else {
               firstFound = true;
               firstIsFirst = true;
-              firstEntryIndex = j;
-            } else if (monomers[j] == rules[i].secondMonomer + add) {
-              firstFound = true;
-              firstIsFirst = false;
-              firstEntryIndex = j;
-            } else {
-              continue;
+              firstEntryIndex = k;
             }
           }
         }
-      }
 
-      if (!(firstFound && secondFound))
-        result[i] = [-1, -1, -1];
-      else if (firstIsFirst)
-        result[i] = [firstEntryIndex, secondEntryIndex, i];
-      else
-        result[i] = [secondEntryIndex, firstEntryIndex, i];
+        if (!(firstFound && secondFound))
+          continue;
+        else if (firstIsFirst)
+          result.push([firstEntryIndex, secondEntryIndex, i]);
+        else
+          result.push([secondEntryIndex, firstEntryIndex, i]);
+      }
     }
 
     return result;
@@ -579,21 +615,22 @@ export class Chain {
     const allPos2: number [] = [];
     const allAttaches1: number [] = [];
     const allAttaches2: number [] = [];
-    const ruleCount = rules.length;
+    const count = positions.length;
 
-    for (let i = 0; i < ruleCount; i++) {
+    for (let i = 0; i < count; i++) {
       if (positions[i][0] == -1)
         continue;
 
-      const firstMonomer = monomers[positions[i][0]];
-      const secondMonomer = monomers[positions[i][1]];
-      monomers[positions[i][0]] = monomers[positions[i][0]].replace(firstMonomer, rules[i].firstSubstitution);
-      monomers[positions[i][1]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondSubstitution);
+      const ruleNum = positions [i][2];
+      const code = rules[ruleNum].code;
+
+      monomers[positions[i][0]] = monomers[positions[i][0]].replace(`(${code})`, '');
+      monomers[positions[i][1]] = monomers[positions[i][1]].replace(`(${code})`, '');
 
       allPos1.push(positions[i][0] + 1);
       allPos2.push(positions[i][1] + 1);
-      allAttaches1.push(rules[i].firstLinkingGroup);
-      allAttaches2.push(rules[i].secondLinkingGroup);
+      allAttaches1.push(rules[ruleNum].firstLinkingGroup);
+      allAttaches2.push(rules[ruleNum].secondLinkingGroup);
     }
 
     return [monomers, allPos1, allPos2, allAttaches1, allAttaches2];
@@ -604,16 +641,16 @@ export class Chain {
     const allPos1: number [] = [];
     const allPos2: number [] = [];
     const rule: number [] = [];
-    const ruleCount = rules.length;
+    const count = positions.length;
 
-    for (let i = 0; i < ruleCount; i++) {
+    for (let i = 0; i < count; i++) {
       if (positions[i][0] == -1)
         continue;
 
-      const firstMonomer = monomers[positions[i][0]];
-      const secondMonomer = monomers[positions[i][1]];
-      monomers[positions[i][0]] = monomers[positions[i][0]].replace(firstMonomer, rules[i].firstMonomer);
-      monomers[positions[i][1]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondMonomer);
+      const ruleNum = positions [i][2];
+      const code = rules[ruleNum].code;
+      monomers[positions[i][0]] = monomers[positions[i][0]].replace(`(${code})`, '');
+      monomers[positions[i][1]] = monomers[positions[i][1]].replace(`(${code})`, '');
 
       allPos1.push(positions[i][0] + 1);
       allPos2.push(positions[i][1] + 1);

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

@@ -2,8 +2,7 @@
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
-import {Rules, RuleReaction} from '../pt-rules';
-import {InvalidReactionError, MonomerNotFoundError} from '../types';
+import {Rules} from './pt-rules';
 import {Chain} from './pt-chain';
 
 import {_package} from '../../package';

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

@@ -8,7 +8,7 @@ import {RDModule, RDMol, RDReaction, MolList, RDReactionResult} from '@datagrok-
 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} from '../pt-rules';
+import {Rules, RuleReaction, getMonomerPairs} from './pt-rules';
 import {InvalidReactionError, MonomerNotFoundError} from '../types';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 
@@ -128,39 +128,48 @@ function getNewGroups(monomer1: Monomer, monomer2: Monomer): RGroup[] {
   return groups;
 }
 
-export function getNewMonomer(rdkit: RDModule, mLib: IMonomerLib, rule: RuleReaction): [string, Monomer] {
+export function getNewMonomers(rdkit: RDModule, mLib: IMonomerLib, rule: RuleReaction): [string[], Monomer[]] {
   const reacSmarts = rule.reaction;
   const monomerName = rule.name;
 
-  const monomer1 = mLib.getMonomer('PEPTIDE', rule.firstMonomer);
-  if (!monomer1) throw new MonomerNotFoundError('PEPTIDE', rule.firstMonomer);
-  const monomer2 = mLib.getMonomer('PEPTIDE', rule.secondMonomer);
-  if (!monomer2) throw new MonomerNotFoundError('PEPTIDE', rule.secondMonomer);
-
-  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'}}});
-
-  return [monomerName, resMonomer];
+  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> {
@@ -171,8 +180,9 @@ export async function getOverriddenLibrary(rules: Rules): Promise<IMonomerLibBas
   const argLib: { [symbol: string]: Monomer } = {};
 
   for (let i = 0; i < rules.reactionRules.length; i++) {
-    const [name, monomer] = getNewMonomer(rdkit, systemMonomerLib, rules.reactionRules[i]);
-    argLib[name] = monomer;
+    const [names, monomers] = getNewMonomers(rdkit, systemMonomerLib, rules.reactionRules[i]);
+    for (let j = 0; j < names.length; j ++)
+      argLib[names[j]] = monomers[j];
   }
 
   const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: argLib};

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

@@ -0,0 +1,231 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import {ActiveFiles} from '@datagrok-libraries/utils/src/settings/active-files-base';
+import {RulesManager} from './rule-manager';
+
+export const RULES_PATH = 'System:AppData/SequenceTranslator/polytool-rules/';
+export const RULES_STORAGE_NAME = 'Polytool';
+export const RULES_TYPE_LINK = 'link';
+export const RULES_TYPE_REACTION = 'reaction';
+export const RULES_TYPE_HOMODIMER = 'fragmentDuplication';
+export const RULES_TYPE_HETERODIMER = 'differentFragments';
+
+const NAME_CODE = 'code';
+const NAME_FIRST_MONOMERS = 'firstMonomers';
+const NAME_SECOND_MONOMERS = 'secondMonomers';
+const NAME_REACTION_NAME = 'name';
+const NAME_FIRST_LINK = 'firstLinkingGroup';
+const NAME_SECOND_LINK = 'secondLinkingGroup';
+
+export class RuleInputs extends ActiveFiles {
+  constructor(
+    path: string, userStorageName: string, ext: string,
+    options?: { onValueChanged: (value: string[]) => void }
+  ) {
+    super(path, userStorageName, ext, options);
+  }
+
+  override createInput(available: string, isChecked: boolean): DG.InputBase<boolean> {
+    const res = super.createInput(available, isChecked);
+
+    const editIcon = ui.icons.edit(async () => {
+      const rulesManager = await RulesManager.getInstance(available);
+      //await rulesManager.show();
+      grok.shell.addView(await rulesManager.getView());
+    }, 'Edit rules');
+
+    res.addOptions(editIcon);
+
+    return res;
+  }
+}
+
+export type RuleLink = {
+  code: number,
+  firstMonomers: string[],
+  secondMonomers: string[],
+  firstLinkingGroup: number,
+  secondLinkingGroup: number
+}
+
+export type RuleReaction = {
+  code: number,
+  firstMonomers: string[],
+  secondMonomers: string[],
+  reaction: string,
+  name: string
+}
+
+export class Rules {
+  homodimerCode: string | null;
+  heterodimerCode: string | null;
+  linkRules: RuleLink[];
+  reactionRules: RuleReaction[];
+
+  constructor(homodimerCode: string | null, heterodimerCode: string | null,
+    linkRules: RuleLink[], reactionRules: RuleReaction[]) {
+    this.homodimerCode = homodimerCode;
+    this.heterodimerCode = heterodimerCode;
+    this.linkRules = linkRules;
+    this.reactionRules = reactionRules;
+  }
+
+  set homodimer(code: string) {
+    this.homodimerCode = code;
+  }
+
+  set heterodimer(code: string) {
+    this.heterodimerCode = code;
+  }
+
+  addLinkRules(rules: RuleLink[]): void {
+    for (let j = 0; j < rules.length; j++)
+      this.linkRules.push(rules[j]);
+  }
+
+  addSynthesisRules(rules: RuleReaction[]): void {
+    for (let j = 0; j < rules.length; j++)
+      this.reactionRules.push(rules[j]);
+  }
+
+  getLinkRulesDf(): DG.DataFrame {
+    const length = this.linkRules.length;
+    const codeCol = DG.Column.int(NAME_CODE, length);
+    const firstMonomerCol = DG.Column.string(NAME_FIRST_MONOMERS, length);
+    const secondMonomerCol = DG.Column.string(NAME_SECOND_MONOMERS, length);
+    const firstLinkingGroup = DG.Column.int(NAME_FIRST_LINK, length);
+    const secondLinkingGroup = DG.Column.int(NAME_SECOND_LINK, length);
+
+    for (let i = 0; i < length; i++) {
+      codeCol.set(i, this.linkRules[i].code);
+      firstMonomerCol.set(i, this.linkRules[i].firstMonomers.toString());
+      secondMonomerCol.set(i, this.linkRules[i].secondMonomers.toString());
+      firstLinkingGroup.set(i, this.linkRules[i].firstLinkingGroup);
+      secondLinkingGroup.set(i, this.linkRules[i].secondLinkingGroup);
+    }
+
+    return DG.DataFrame.fromColumns([
+      codeCol, firstMonomerCol, secondMonomerCol, firstLinkingGroup, secondLinkingGroup
+    ]);
+  }
+
+  getSynthesisRulesDf(): DG.DataFrame {
+    const length = this.reactionRules.length;
+    const codeCol = DG.Column.int(NAME_CODE, length);
+    const firstMonomerCol = DG.Column.string(NAME_FIRST_MONOMERS, length);
+    const secondMonomerCol = DG.Column.string(NAME_SECOND_MONOMERS, length);
+    const name = DG.Column.string(NAME_REACTION_NAME, length);
+    const firstReactant = DG.Column.string('firstReactant', length);
+    const secondReactant = DG.Column.string('secondReactant', length);
+    const product = DG.Column.string('product', length);
+
+    for (let i = 0; i < length; i++) {
+      codeCol.set(i, this.reactionRules[i].code);
+      firstMonomerCol.set(i, this.reactionRules[i].firstMonomers.toString());
+      secondMonomerCol.set(i, this.reactionRules[i].secondMonomers.toString());
+      name.set(i, this.reactionRules[i].name);
+
+      const reaction = this.reactionRules[i].reaction.split('>>');
+      const reactants = reaction[0].split('.');
+
+      firstReactant.set(i, reactants[0]);
+      secondReactant.set(i, reactants[1]);
+      product.set(i, reaction[1]);
+    }
+    firstReactant.semType = DG.SEMTYPE.MOLECULE;
+    secondReactant.semType = DG.SEMTYPE.MOLECULE;
+    product.semType = DG.SEMTYPE.MOLECULE;
+
+
+    return DG.DataFrame.fromColumns([
+      name, firstReactant, secondReactant, product, codeCol, firstMonomerCol, secondMonomerCol
+    ]);
+  }
+
+  setLinkRules(df: DG.DataFrame) : void {
+    const length = df.rowCount;
+    const rules: RuleLink [] = new Array<RuleLink>(length);
+    const codeCol = df.columns.byName(NAME_CODE);
+    const firstMonomerCol = df.columns.byName(NAME_FIRST_MONOMERS);
+    const secondMonomerCol = df.columns.byName(NAME_SECOND_MONOMERS);
+    const firstLink = df.columns.byName(NAME_FIRST_LINK);
+    const secondLink = df.columns.byName(NAME_SECOND_LINK);
+
+
+    for (let i = 0; i < length; i++) {
+      const rule = {
+        code: codeCol.get(i),
+        firstMonomers: firstMonomerCol.get(i).split(','),
+        secondMonomers: secondMonomerCol.get(i).split(','),
+        firstLinkingGroup: firstLink.get(i),
+        secondLinkingGroup: secondLink.get(i)
+      };
+
+      rules[i] = rule;
+    }
+
+    this.linkRules = rules;
+  }
+
+  setSynthesisRules(df: DG.DataFrame) : void {
+    const length = df.rowCount;
+    const rules: RuleReaction [] = new Array<RuleReaction>(length);
+    const codeCol = df.columns.byName(NAME_CODE);
+    const firstMonomerCol = df.columns.byName(NAME_FIRST_MONOMERS);
+    const secondMonomerCol = df.columns.byName(NAME_SECOND_MONOMERS);
+    const name = df.columns.byName(NAME_REACTION_NAME);
+    const firstReactant = df.columns.byName('firstReactant');
+    const secondReactant = df.columns.byName('secondReactant');
+    const product = df.columns.byName('product');
+
+    for (let i = 0; i < length; i++) {
+      const smartsReaction = `${firstReactant.get(i)}.${secondReactant.get(i)}>>${product.get(i)}`;
+
+      const rule = {
+        code: codeCol.get(i),
+        firstMonomers: firstMonomerCol.get(i).split(','),
+        secondMonomers: secondMonomerCol.get(i).split(','),
+        reaction: smartsReaction,
+        name: name.get(i)
+      };
+
+      rules[i] = rule;
+    }
+
+    this.reactionRules = rules;
+  }
+}
+
+export async function getRules(ruleFiles: string[]): Promise<Rules> {
+  const fileSource = new DG.FileSource(RULES_PATH);
+  const rules: Rules = new Rules(null, null, [], []);
+
+  for (let i = 0; i < ruleFiles.length; i++) {
+    const rulesRaw = await fileSource.readAsText(ruleFiles[i].replace(RULES_PATH, ''));
+    const ruleSingle : Rules = JSON.parse(rulesRaw);
+
+    rules.homodimer = ruleSingle.homodimerCode!;
+    rules.heterodimer = ruleSingle.heterodimerCode!;
+    rules.addLinkRules(ruleSingle.linkRules);
+    rules.addSynthesisRules(ruleSingle.reactionRules);
+  }
+
+  return rules;
+}
+
+export function getMonomerPairs(rule: RuleLink | RuleReaction) : [string[], string[]] {
+  const allPairsNum = rule.firstMonomers.length*rule.secondMonomers.length;
+  const firstMonomers = new Array<string>(allPairsNum);
+  const secondMonomers = new Array<string>(allPairsNum);
+
+  let counter = 0;
+  for (let i = 0; i < rule.firstMonomers.length; i++) {
+    for (let j = 0; j < rule.secondMonomers.length; j++) {
+      firstMonomers[counter] = rule.firstMonomers[i];
+      secondMonomers[counter] = rule.secondMonomers[j];
+      counter++;
+    }
+  }
+
+  return [firstMonomers, secondMonomers];
+}