@datagrok/bio 1.5.9 → 1.7.0

package/src/utils/cell-renderer.ts

@@ -1,33 +1,36 @@
-import * as C from "./constants";
-import {getSeparator} from "./misc";
-import {ChemPalette} from "./chem-palette";
+import * as C from './constants';
 import * as DG from 'datagrok-api/dg';
-import {AminoacidsPalettes} from "@datagrok-libraries/bio/src/aminoacids";
-import {NucleotidesPalettes} from "@datagrok-libraries/bio/src/nucleotides";
-import {UnknownSeqPalettes} from "@datagrok-libraries/bio/src/unknown";
-import {SplitterFunc, WebLogo} from "@datagrok-libraries/bio/src/viewers/web-logo";
-import {SeqPalette} from "@datagrok-libraries/bio/src/seq-palettes";
+import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
+import {NucleotidesPalettes} from '@datagrok-libraries/bio/src/nucleotides';
+import {UnknownSeqPalettes} from '@datagrok-libraries/bio/src/unknown';
+import {SplitterFunc, WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import * as ui from 'datagrok-api/ui';
 
 const lru = new DG.LruCache<any, any>();
+const undefinedColor = 'rgb(100,100,100)';
 
-function getPalleteByType(paletteType: string): SeqPalette  {
+function getPalleteByType(paletteType: string): SeqPalette {
   switch (paletteType) {
-    case 'PT':
-      return  AminoacidsPalettes.GrokGroups;
-    case 'NT':
-      return  NucleotidesPalettes.Chromatogram
-      // other
-    default:
-      return UnknownSeqPalettes.Color;
+  case 'PT':
+    return AminoacidsPalettes.GrokGroups;
+  case 'NT':
+    return NucleotidesPalettes.Chromatogram;
+  case 'DNA':
+    return NucleotidesPalettes.Chromatogram;
+  case 'RNA':
+    return NucleotidesPalettes.Chromatogram;
+    // other
+  default:
+    return UnknownSeqPalettes.Color;
   }
 }
 
 export function processSequence(subParts: string[]): [string[], boolean] {
   const simplified = !subParts.some((amino, index) =>
-      amino.length > 1 &&
-      index != 0 &&
-      index != subParts.length - 1);
+    amino.length > 1 &&
+    index != 0 &&
+    index != subParts.length - 1);
 
   const text: string[] = [];
   const gap = simplified ? '' : ' ';
@@ -39,6 +42,7 @@ export function processSequence(subParts: string[]): [string[], boolean] {
   });
   return [text, simplified];
 }
+
 /**
  * A function that prints a string aligned to left or centered.
  *
@@ -48,7 +52,7 @@ export function processSequence(subParts: string[]): [string[], boolean] {
  * @param {number} h Height.
  * @param {CanvasRenderingContext2D} g Canvas rendering context.
  * @param {string} s String to print.
- * @param {string} [color=ChemPalette.undefinedColor] String color.
+ * @param {string} [color=undefinedColor] String color.
  * @param {number} [pivot=0] Pirvot.
  * @param {boolean} [left=false] Is left aligned.
  * @param {boolean} [hideMod=false] Hide amino acid redidue modifications.
@@ -56,13 +60,16 @@ export function processSequence(subParts: string[]): [string[], boolean] {
  * @return {number} x coordinate to start printing at.
  */
 function printLeftOrCentered(
-    x: number, y: number, w: number, h: number,
-    g: CanvasRenderingContext2D, s: string, color = ChemPalette.undefinedColor,
-    pivot: number = 0, left = false, hideMod = false, transparencyRate: number = 1.0,
-    separator: string = ''): number {
+  x: number, y: number, w: number, h: number,
+  g: CanvasRenderingContext2D, s: string, color = undefinedColor,
+  pivot: number = 0, left = false, hideMod = false, transparencyRate: number = 1.0,
+  separator: string = '', last: boolean = false): number {
   g.textAlign = 'start';
   let colorPart = s.substring(0);
   let grayPart = separator;
+  if (last) {
+    grayPart = '';
+  }
   const textSize = g.measureText(colorPart + grayPart);
   const indent = 5;
 
@@ -87,44 +94,6 @@ function printLeftOrCentered(
     return x + dx + colorTextSize.width;
   }
 }
-function renderSequense(
-      g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
-      cellStyle: DG.GridCellStyle,
-): void {
-    const grid = gridCell.grid;
-    const cell = gridCell.cell;
-    const [type, subtype, paletteType] =  gridCell.cell.column.getTag(DG.TAGS.UNITS).split(":");
-    w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
-    g.save();
-    g.beginPath();
-    g.rect(x, y, w, h);
-    g.clip();
-    g.font = '12px monospace';
-    g.textBaseline = 'top';
-    const s: string = cell.value ?? '';
-
-  //TODO: can this be replaced/merged with splitSequence?
-  const units = gridCell.cell.column.getTag(DG.TAGS.UNITS);
-
-  const palette = getPalleteByType(paletteType);
-
-  const separator = gridCell.cell.column.getTag('separator') ?? '';
-  const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, gridCell.cell.column.getTag('separator') );// splitter,
-
-  const subParts:string[] =  splitterFunc(cell.value);
-
-  const textSize = g.measureText(subParts.join(''));
-  let x1 = Math.max(x, x + (w - textSize.width) / 2);
-
-  subParts.forEach((amino, index) => {
-    let [color, outerAmino,, pivot] = ChemPalette.getColorAAPivot(amino);
-    color = palette.get(amino);
-    g.fillStyle = ChemPalette.undefinedColor;
-    x1 = printLeftOrCentered(x1, y, w, h, g, amino, color, pivot, true, false, 1.0, separator);
-  });
-
-  g.restore();
-}
 
 export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
 
@@ -149,19 +118,19 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
    * @memberof AlignedSequenceCellRenderer
    */
   render(
-      g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
-      cellStyle: DG.GridCellStyle,
+    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
+    cellStyle: DG.GridCellStyle,
   ): void {
     const grid = gridCell.grid;
     const cell = gridCell.cell;
     const tag = gridCell.cell.column.getTag(DG.TAGS.UNITS);
     if (tag === 'HELM') {
-      let host = ui.div([], { style: { width: `${w}px`, height: `${h}px`}});
+      let host = ui.div([], {style: {width: `${w}px`, height: `${h}px`}});
       host.setAttribute('dataformat', 'helm');
       host.setAttribute('data', gridCell.cell.value);
       gridCell.element = host;
       //@ts-ignore
-      var canvas = new JSDraw2.Editor(host, { width: w, height: h, skin: "w8", viewonly: true });
+      var canvas = new JSDraw2.Editor(host, {width: w, height: h, skin: 'w8', viewonly: true});
       var formula = canvas.getFormula(true);
       if (!formula) {
         gridCell.element = ui.divText(gridCell.cell.value, {style: {color: 'red'}});
@@ -174,7 +143,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
         lru.set(gridCell.cell.value, result);
       }
     } else {
-      const [type, subtype, paletteType] =  gridCell.cell.column.getTag(DG.TAGS.UNITS).split(":");
+      const [type, subtype, paletteType] = gridCell.cell.column.getTag(DG.TAGS.UNITS).split(':');
       w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
       g.save();
       g.beginPath();
@@ -190,19 +159,22 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       const palette = getPalleteByType(paletteType);
 
       const separator = gridCell.cell.column.getTag('separator') ?? '';
-      const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, gridCell.cell.column.getTag('separator') );// splitter,
+      const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, gridCell.cell.column.getTag('separator'));// splitter,
 
-      const subParts:string[] =  splitterFunc(cell.value);
-      console.log(subParts);
+      const subParts: string[] = splitterFunc(cell.value);
+      // console.log(subParts);
 
       const textSize = g.measureText(subParts.join(''));
-      let x1 = Math.max(x, x + (w - textSize.width) / 2);
-
+      let x1 = x;
+      let color = undefinedColor;
       subParts.forEach((amino, index) => {
-        let [color, outerAmino,, pivot] = ChemPalette.getColorAAPivot(amino);
         color = palette.get(amino);
-        g.fillStyle = ChemPalette.undefinedColor;
-        x1 = printLeftOrCentered(x1, y, w, h, g, amino, color, pivot, true, false, 1.0, separator);
+        g.fillStyle = undefinedColor;
+        let last = false;
+        if (index === subParts.length - 1) {
+          last = true;
+        }
+        x1 = printLeftOrCentered(x1, y, w, h, g, amino, color, 0, true, false, 1.0, separator, last);
       });
 
       g.restore();

package/src/utils/convert.ts

@@ -16,26 +16,22 @@ export function convert(col: DG.Column): void {
     NOTATION.SEPARATOR,
     NOTATION.HELM
   ];
-  const filtered = notations.filter((e) => e !== current);
-  const targetNotationInput = ui.choiceInput('Convert to', filtered[0], filtered);
+  const separatorArray = ['-', '.', '/'];
+  const filteredNotations = notations.filter((e) => e !== current);
+  const targetNotationInput = ui.choiceInput('Convert to', filteredNotations[0], filteredNotations);
 
-  const separatorInput = ui.choiceInput('separator', '-', ['-', '.', '/']);
+  const separatorInput = ui.choiceInput('Choose separator', separatorArray[0], separatorArray);
 
-  ui.dialog('Convert sequence')
+  ui.dialog('Convert sequence notation')
     .add(ui.div([
-      ui.h1('current notation'),
-      ui.div(current),
-      targetNotationInput.root
-    ]))
-    .add(ui.div([
-      ui.h1('Separator'),
-      separatorInput,
-
+      ui.h1('Current notation: ' + current),
+      targetNotationInput.root,
+      // TODO: conditional separator input
+      separatorInput.root
     ]))
     .onOK(() => {
       //TODO: create new converted column
-      //const targetNotation: NOTATION = strToEnum<NOTATION>(NOTATION, targetNotationInput.value)!;
-      const targetNotation: NOTATION = targetNotationInput.value as NOTATION;
+      const targetNotation = targetNotationInput.value as NOTATION;
       const separator = separatorInput.value!;
       const newColumn = converter.convert(targetNotation, separator);
       col.dataFrame.columns.add(newColumn);

package/src/utils/multiple-sequence-alignment.ts

@@ -50,10 +50,12 @@ export async function runKalign(srcCol: DG.Column, isAligned = false): Promise<D
 
   await CLI.fs.writeFile('input.fa', fasta);
   const output = await CLI.exec('kalign input.fa -f fasta -o result.fasta');
-  const buf = await CLI.cat('result.fasta');
-
   console.warn(output);
 
+  const buf = await CLI.cat('result.fasta');
+  if (!buf)
+    throw new Error(`kalign output no result`);
+
   const aligned = _fastaToStrings(buf).slice(0, sequences.length);
   const tgtCol = DG.Column.fromStrings(`msa(${srcCol.name})`, aligned);
 

package/src/utils/notation-converter.ts

@@ -3,9 +3,9 @@ import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
 
 /** enum type to simplify setting "user-friendly" notation if necessary */
 export const enum NOTATION {
-  FASTA = 'fasta',
-  SEPARATOR = 'separator',
-  HELM = 'helm'
+  FASTA = 'FASTA',
+  SEPARATOR = 'SEPARATOR',
+  HELM = 'HELM'
 }
 
 /** Class for handling conversion of notation systems in Macromolecule columns */
@@ -32,14 +32,15 @@ export class NotationConverter {
 
   public toHelm(targetNotation: NOTATION): boolean { return targetNotation === NOTATION.HELM; }
 
-  // TODO: isRna
-  public isRna(): boolean { return this.sourceUnits.toLowerCase().endsWith('nt'); }
+  public isRna(): boolean { return this.sourceUnits.toLowerCase().endsWith('rna'); }
+
+  public isDna(): boolean { return this.sourceUnits.toLowerCase().endsWith('dna'); }
 
   public isPeptide(): boolean { return this.sourceUnits.toLowerCase().endsWith('pt'); }
 
   /** Associate notation types with the corresponding units */
   /**
-   * @return {NOTATION} notation associated with the units type
+   * @return {NOTATION}     Notation associated with the units type
    */
   private determineSourceNotation(): NOTATION {
     if (this.sourceUnits.toLowerCase().startsWith('fasta'))
@@ -51,7 +52,33 @@ export class NotationConverter {
       return NOTATION.HELM;
   }
 
-  // TODO: write doc
+  /**
+   * Determine the separator used in SEPARATOR column
+   *
+   * @return {string} The detected separator
+   */
+  private determineSeparator(): string {
+    //   TODO: figure out how to determine the separator efficiently
+    const col = this.sourceColumn;
+    let i = 0;
+    const re = /[^a-z]/;
+    while (i < col.length) {
+      const molecule = col.get(i);
+      const foundSeparator = molecule.toLowerCase().match(re);
+      if (foundSeparator)
+        return foundSeparator[0];
+      i++;
+    }
+    throw new Error('No separators found');
+  }
+
+  /**
+   * Create a new empty column of the specified notation type and the same
+   * length as sourceColumn
+   *
+   * @param {NOTATION} targetNotation
+   * @return {DG.Column}
+   */
   private getNewColumn(targetNotation: NOTATION): DG.Column {
     const col = this.sourceColumn;
     const len = col.length;
@@ -60,74 +87,199 @@ export class NotationConverter {
     // dummy code
     const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill(''));
     newColumn.semType = 'Macromolecule';
-    const newUnits = this.sourceUnits.replace(this.sourceNotation.toString(), targetNotation.toString());
-    newColumn.setTag(DG.TAGS.UNITS, newUnits);
-    // TODO: determine all the qualifiers (units, ...), perhaps, using detectors
+    newColumn.setTag(
+      DG.TAGS.UNITS,
+      this.sourceUnits.replace(
+        this.sourceNotation.toLowerCase().toString(),
+        targetNotation.toLowerCase().toString()
+      )
+    );
+    // TODO: specify cell renderers for all cases
+    if (this.toFasta(targetNotation)) {
+      newColumn.setTag(
+        DG.TAGS.CELL_RENDERER,
+        'Macromolecule');
+    }
     return newColumn;
   }
 
-  // TODO: write doc
-  private convertFastaToSeparator(separator: string): DG.Column {
-    // TODO: implementation
-    // * specify separator
-    // * fasta gap symbol should NOT be considered '-' only, but set as a parameter
-    // * in fasta every position is a monomer (no multi-char monomers), call splitToMonomers() method
-    // * in the resulting jagged array, every gap symbol is to be replaced by
-    // the empty string, while the monomers, to be separated by the separator
-    // (specified as a parameter)
-    // On splitToMonomers(): /libraries/bio/src/viewers/WebLogo --> getSplitter
-
-    const gapSymbol = '-'; // to be specified as an argument
+  /**
+   * Convert a Macromolecule column from FASTA to SEPARATOR notation
+   *
+   * @param {string} separator  A specific separator to be used
+   * @param {string} gapSymbol  Gap symbol in FASTA, '-' by default
+   * @return {DG.Column}        A new column in SEPARATOR notation
+   */
+  private convertFastaToSeparator(separator: string, gapSymbol: string = '-'): DG.Column {
+    // a function splitting FASTA sequence into an array of monomers:
     const splitterAsFasta = WebLogo.splitterAsFasta;
+
     const newColumn = this.getNewColumn(NOTATION.SEPARATOR);
+    // assign the values to the newly created empty column
     newColumn.init((idx: number) => {
-      const sourcePolymer = this.sourceColumn.get(idx);
-      const monomersArray = splitterAsFasta(sourcePolymer);
-      for (let i = 0; i < monomersArray.length; i++) {
-        if (monomersArray[i] === gapSymbol)
-          monomersArray[i] = '';
+      const fastaPolymer = this.sourceColumn.get(idx);
+      const fastaMonomersArray = splitterAsFasta(fastaPolymer);
+      for (let i = 0; i < fastaMonomersArray.length; i++) {
+        if (fastaMonomersArray[i] === gapSymbol)
+          fastaMonomersArray[i] = '';
       }
-      return monomersArray.join(separator);
+      return fastaMonomersArray.join(separator);
     });
     return newColumn;
   }
 
-  private wrapRnaNucleotideToHelm(monomer: string) {
+  /**
+   * Convert a Macromolecule column from FASTA to HELM
+   *
+   * @param {string} fastaGapSymbol   Optional fasta gap symbol
+   * @param {string} helmGapSymbol    Optional helm gap symbol
+   * @return {DG.Column}              A new column in HELM notation
+   */
+  private convertFastaToHelm(
+    fastaGapSymbol: string = '-',
+    helmGapSymbol: string = '*'
+  ): DG.Column {
+    // a function splitting FASTA sequence into an array of monomers
+    const splitterAsFasta = WebLogo.splitterAsFasta;
 
-  }
+    const prefix = (this.isDna()) ? 'DNA1{' :
+      (this.isRna()) ? 'RNA1{' :
+        (this.isPeptide()) ? 'PEPTIDE1{' :
+          'Unknown'; // this case should be handled as exceptional
+
+    if (prefix === 'Unknown')
+      throw new Error('Neither peptide, nor nucleotide');
+
+    const postfix = '}$$$';
+    const leftWrapper = (this.isDna()) ? 'D(' :
+      (this.isRna()) ? 'R(' : ''; // no wrapper for peptides
+    const rightWrapper = (this.isDna() || this.isRna()) ? ')P' : ''; // no wrapper for peptides
 
-  private convertFastaToHelm(): DG.Column {
-    const gapSymbol = '-'; // to be specified as an argument
-    const splitterAsFasta = WebLogo.splitterAsFasta;
     const newColumn = this.getNewColumn(NOTATION.HELM);
+    // assign the values to the empty column
     newColumn.init((idx: number) => {
-      const sourcePolymer = this.sourceColumn.get(idx);
-      const monomersArray = splitterAsFasta(sourcePolymer);
-      for (let i = 0; i < monomersArray.length; i++) {
-        // // TODO: handle gap symbols -- replace by asterisk
-        // if (monomersArray[i] === gapSymbol)
-        //   monomersArray[i] = '*';
-        // else
+      const fastaPolymer = this.sourceColumn.get(idx);
+      const fastaMonomersArray = splitterAsFasta(fastaPolymer);
+      const helmArray = [prefix];
+      let firstIteration = true;
+      for (let i = 0; i < fastaMonomersArray.length; i++) {
+        if (fastaMonomersArray[i] === fastaGapSymbol) {
+          // TODO: verify the correctness of gap symbols handling
+          helmArray.push(helmGapSymbol);
+        } else {
+          const dot = firstIteration ? '' : '.';
+          const item = [dot, leftWrapper, fastaMonomersArray[i], rightWrapper];
+          helmArray.push(item.join(''));
+        }
+        firstIteration = false;
       }
-      // TODO: determine conditionally (if isDna(), or isRna(), or isPeptide()) the template
-      return monomersArray.join('');
+      helmArray.push(postfix);
+      return helmArray.join('');
     });
     return newColumn;
   }
 
-  private convertSeparatorToFasta(): DG.Column {
+  private handleSeparatorItemForFasta(
+    idx: number,
+    separatorItemsArray: string[],
+    separator: string,
+    gapSymbol: string,
+    fastaMonomersArray: string[]
+  ): void {
+    const item = separatorItemsArray[idx];
+    if (item.length > 1) {
+      // the case of a multi-character monomer
+      const monomer = '[' + item + ']';
+      fastaMonomersArray.push(monomer);
+    }
+    if (item === separator) {
+      if (idx !== 0 && separatorItemsArray[idx - 1] === separator)
+        fastaMonomersArray.push(gapSymbol);
+    }
+  }
+
+  private convertSeparatorToFasta(
+    separator: string | null = null,
+    gapSymbol: string = '-'
+  ): DG.Column {
     // TODO: implementation
     // * similarly to fasta2separator, divide string into monomers
     // * adjacent separators is a gap (symbol to be specified)
     // * the monomers MUST be single-character onles, otherwise forbid
+    // * NO, they can be multi-characters
     // conversion
-    //getSplitterWithSeparator
-    return this.getNewColumn(NOTATION.FASTA);
+    // * consider automatic determining the separator
+
+    // if (separator === null)
+    //   separator = this.determineSeparator();
+
+    // a function splitting FASTA sequence into an array of monomers
+    //const splitterAsSeparator = WebLogo.getSplitterWithSeparator(separator);
+    const splitter = WebLogo.getSplitterForColumn(this._sourceColumn);
+
+    const newColumn = this.getNewColumn(NOTATION.FASTA);
+    // assign the values to the empty column
+    newColumn.init((idx: number) => {
+      const separatorPolymer = this.sourceColumn.get(idx);
+      // items can be monomers or separators
+      const separatorItemsArray = splitter(separatorPolymer);
+      const fastaMonomersArray: string[] = [];
+      for (let i = 0; i < separatorItemsArray.length; i++) {
+        const item = separatorItemsArray[i];
+        if (item.length === 0) {
+          fastaMonomersArray.push(gapSymbol);
+        } else if (item.length > 1) {
+          // the case of a multi-character monomer
+          const monomer = '[' + item + ']';
+          fastaMonomersArray.push(monomer);
+        } else {
+          fastaMonomersArray.push(item);
+        }
+      }
+      return fastaMonomersArray.join('');
+    });
+    return newColumn;
   }
 
-  private convertSeparatorToHelm(): DG.Column {
-    // TODO: implementation
-    return this.getNewColumn(NOTATION.HELM);
+  private convertSeparatorToHelm(fastaGapSymbol: string = '-', helmGapSymbol: string = '*'): DG.Column {
+    // a function splitting FASTA sequence into an array of monomers
+    const splitter = WebLogo.getSplitterForColumn(this._sourceColumn);
+
+    const prefix = (this.isDna()) ? 'DNA1{' :
+      (this.isRna()) ? 'RNA1{' :
+        (this.isPeptide()) ? 'PEPTIDE1{' :
+          'Unknown'; // this case should be handled as exceptional
+
+    if (prefix === 'Unknown')
+      throw new Error('Neither peptide, nor nucleotide');
+
+    const postfix = '}$$$';
+    const leftWrapper = (this.isDna()) ? 'D(' :
+      (this.isRna()) ? 'R(' : ''; // no wrapper for peptides
+    const rightWrapper = (this.isDna() || this.isRna()) ? ')P' : ''; // no wrapper for peptides
+
+    const newColumn = this.getNewColumn(NOTATION.HELM);
+    // assign the values to the empty column
+    newColumn.init((idx: number) => {
+      const fastaPolymer = this.sourceColumn.get(idx);
+      const fastaMonomersArray = splitter(fastaPolymer);
+      const helmArray = [prefix];
+      let firstIteration = true;
+      for (let i = 0; i < fastaMonomersArray.length; i++) {
+        if (fastaMonomersArray[i] === fastaGapSymbol) {
+          // TODO: verify the correctness of gap symbols handling
+          helmArray.push(helmGapSymbol);
+        } else {
+          const dot = firstIteration ? '' : '.';
+          const item = [dot, leftWrapper, fastaMonomersArray[i], rightWrapper];
+          helmArray.push(item.join(''));
+        }
+        firstIteration = false;
+      }
+      helmArray.push(postfix);
+      return helmArray.join('');
+    });
+    return newColumn;
   }
 
   private convertHelmToFasta(): DG.Column {
@@ -140,17 +292,25 @@ export class NotationConverter {
     return this.getNewColumn(NOTATION.SEPARATOR);
   }
 
-  /** Dispatcher method for notation conversion */
-  // TODO: write the bodies of converter methods
-  public convert(targetNotation: NOTATION, separator: string | null): DG.Column {
+  /** Dispatcher method for notation conversion
+   *
+   * @param {NOTATION} targetNotation   Notation we want to convert to
+   * @param {string | null} tgtSeparator   Possible separator
+   * @return {DG.Column}                Converted column
+   */
+  public convert(targetNotation: NOTATION, tgtSeparator: string | null = null): DG.Column {
+    // possible exceptions
     if (this.sourceNotation === targetNotation)
-      throw new Error('Target notation is not specified');
-    if (this.isFasta() && this.toSeparator(targetNotation))
-      return this.convertFastaToSeparator(separator!); // there is the only place where a separator is needed
+      throw new Error('Target notation is invalid');
+    if (this.toSeparator(targetNotation) && tgtSeparator === null)
+      throw new Error('Target separator is not specified');
+
+    if (this.isFasta() && this.toSeparator(targetNotation) && tgtSeparator !== null)
+      return this.convertFastaToSeparator(tgtSeparator);
     else if (this.isFasta() && this.toHelm(targetNotation))
       return this.convertFastaToHelm();
     else if (this.isSeparator() && this.toFasta(targetNotation))
-      return this.convertSeparatorToFasta();
+      return this.convertSeparatorToFasta(tgtSeparator!);
     else if (this.isSeparator() && this.toHelm(targetNotation))
       return this.convertSeparatorToHelm();
     else if (this.isHelm() && this.toFasta(targetNotation))