@datagrok/peptides 0.8.15 → 1.0.2

package/src/utils/misc.ts

@@ -1,24 +1,25 @@
 import * as DG from 'datagrok-api/dg';
-
 import * as C from './constants';
+import * as type from './types';
 
-export function stringToBool(str: string): boolean {
-  return str === 'true' ? true : false;
-}
+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 {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
+import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
 
-export function getSeparator(col: DG.Column<string>): string {
-  const separator = col.tags[C.TAGS.SEPARATOR];
-  if (separator)
-    return separator as string;
-
-  const defaultSeparators = ['.', '-', ' '];
-  const categories = col.categories;
-  const catLen = categories.length;
-  for (const potentialSeparator of defaultSeparators) {
-    if (categories.filter((sequence) => sequence.includes(potentialSeparator)).length == catLen)
-      return potentialSeparator;
+export function getPalleteByType(paletteType: string): SeqPalette {
+  switch (paletteType) {
+  case 'PT':
+    return AminoacidsPalettes.GrokGroups;
+  case 'NT':
+  case 'DNA':
+  case 'RNA':
+    return NucleotidesPalettes.Chromatogram;
+    // other
+  default:
+    return UnknownSeqPalettes.Color;
   }
-  return separator as string ?? '';
 }
 
 export function getTypedArrayConstructor(
@@ -27,3 +28,89 @@ export function getTypedArrayConstructor(
     maxNum < 65536 ? Uint16Array :
       Uint32Array;
 }
+
+export function getSeparator(col: DG.Column<string>): string {
+  return col.getTag(C.TAGS.SEPARATOR) ?? '';
+}
+
+export function splitAlignedPeptides(peptideColumn: DG.Column<string>): DG.DataFrame {
+  const splitter = WebLogo.getSplitterForColumn(peptideColumn);
+  const colLen = peptideColumn.length;
+  const resultDf = DG.DataFrame.create(colLen);
+  let monomerList = splitter(peptideColumn.get(0)!);
+  const columnList: DG.Column<string>[] = [];
+
+  // create columns and fill the first row for faster values filling in the next loop
+  for (let i = 0; i < monomerList.length; i++) {
+    const col = resultDf.columns.addNewString((i + 1).toString());
+    col.set(0, monomerList[i] || '-', false);
+    columnList.push(col);
+  }
+
+  for (let rowIndex = 1; rowIndex < colLen; rowIndex++) {
+    monomerList = splitter(peptideColumn.get(rowIndex)!);
+    monomerList.forEach((monomer, colIndex) => columnList[colIndex].set(rowIndex, monomer || '-', false));
+  }
+
+  return resultDf;
+}
+
+export function scaleActivity(
+  activityScaling: string, df: DG.DataFrame, originalActivityName?: string, cloneBitset = false,
+): [DG.DataFrame, string] {
+  let currentActivityColName = originalActivityName ?? C.COLUMNS_NAMES.ACTIVITY;
+  const flag = df.columns.names().includes(currentActivityColName) &&
+    currentActivityColName === originalActivityName;
+  currentActivityColName = flag ? currentActivityColName : C.COLUMNS_NAMES.ACTIVITY;
+  const tempDf = df.clone(cloneBitset ? df.filter : null, [currentActivityColName]);
+
+  let formula = (v: number) => v;
+  let newColName = 'activity';
+  switch (activityScaling) {
+  case 'none':
+    break;
+  case 'lg':
+    formula = (v: number) => Math.log10(v);
+    newColName = `Log10(${newColName})`;
+    break;
+  case '-lg':
+    formula = (v: number) => -Math.log10(v);
+    newColName = `-Log10(${newColName})`;
+    break;
+  default:
+    throw new Error(`ScalingError: method \`${activityScaling}\` is not available.`);
+  }
+
+  const asCol = tempDf.columns.addNewFloat(C.COLUMNS_NAMES.ACTIVITY_SCALED);
+  const activityCol = df.getCol(currentActivityColName);
+  asCol.init((i) => formula(activityCol.get(i)));
+  df.tags['scaling'] = activityScaling;
+
+  return [tempDf, newColName];
+}
+
+export function calculateBarsData(columns: DG.Column<string>[], selection: DG.BitSet): type.MonomerDfStats {
+  const dfStats: type.MonomerDfStats = {};
+  const columnsLen = columns.length;
+
+  for (let colIndex = 0; colIndex < columnsLen; colIndex++) {
+    const col = columns[colIndex];
+    dfStats[col.name] = calculateBarData(col, selection);
+  }
+
+  return dfStats;
+}
+
+export function calculateBarData(col: DG.Column<string>, selection: DG.BitSet): type.MonomerColStats {
+  const colLen = col.length;
+  const colStats: type.MonomerColStats = {};
+  col.categories.forEach((monomer) => colStats[monomer] = {count: 0, selected: 0});
+
+  for (let rowIndex = 0; rowIndex < colLen; rowIndex++) {
+    const monomerStats = colStats[col.get(rowIndex)!];
+    monomerStats.count += 1;
+    monomerStats.selected += +selection.get(rowIndex);
+  }
+
+  return colStats;
+}

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

@@ -87,7 +87,7 @@ export async function runKalign(col: DG.Column, isAligned = false) : Promise<DG.
 
   const aligned = _fastaToStrings(buf).slice(0, sequences.length);
   const alignedCol = DG.Column.fromStrings(`(${col.name})msa`, _stringsToAligned(aligned));
-  alignedCol.semType = C.SEM_TYPES.ALIGNED_SEQUENCE;
+  alignedCol.semType = C.SEM_TYPES.MACROMOLECULE;
   return alignedCol;
 }
 

package/src/utils/peptide-similarity-space.ts

@@ -7,7 +7,7 @@ import {AlignedSequenceEncoder} from '@datagrok-libraries/bio/src/sequence-encod
 import {DimensionalityReducer} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {
   createDimensinalityReducingWorker,
-  IReduceDimensionalityResult
+  IReduceDimensionalityResult,
 } from '@datagrok-libraries/ml/src/workers/dimensionality-reducing-worker-creator';
 import {Measure, StringMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {Coordinates} from '@datagrok-libraries/utils/src/type-declarations';
@@ -44,7 +44,7 @@ export async function createPeptideSimilaritySpaceViewer(
   const pi = DG.TaskBarProgressIndicator.create('Creating embedding...');
 
   const axesNames = ['~X', '~Y', '~MW'];
-  col ??= table.columns.bySemType(C.SEM_TYPES.ALIGNED_SEQUENCE)!;
+  col ??= table.columns.bySemType(C.SEM_TYPES.MACROMOLECULE)!;
   const columnData = col.toList().map((v) => AlignedSequenceEncoder.clean(v));
 
   const reduceDimRes: IReduceDimensionalityResult = await createDimensinalityReducingWorker(

package/src/utils/types.ts

@@ -1,14 +1,15 @@
 import * as DG from 'datagrok-api/dg';
 
-export type SubstitutionCases = {[aar: string]: number[][][]};
-export type SubstitutionTooltips = { [aar: string]: {}[][]; };
 export type DataFrameDict = {[key: string]: DG.DataFrame};
 
-export namespace BarChart {
-  export type BarPart = {colName : string, aaName : string};
-  export type BarStatsObject = {name: string, count: number, selectedCount: number};
-}
-
 export type UTypedArray = Uint8Array | Uint16Array | Uint32Array;
 //AAR: (Position: (index: indexList))
 export type SubstitutionsInfo = Map<string, Map<string, Map<number, number[] | UTypedArray>>>;
+export type SelectionObject = {[postiton: string]: string[]};
+
+export type HELMMonomer = {at: {[key: string]: string}, id: string, m: string, na: string, n: string, rs: number};
+
+export type MonomerColStats = {[monomer: string]: {count: number, selected: number}};
+export type MonomerDfStats = {[position: string]: MonomerColStats};
+
+export type BarCoordinates = {[monomer: string]: DG.Rect};

package/src/viewers/peptide-space-viewer.ts

@@ -6,19 +6,21 @@ import $ from 'cash-dom';
 
 import {getSequenceMolecularWeight} from '../utils/molecular-measure';
 import {AlignedSequenceEncoder} from '@datagrok-libraries/bio/src/sequence-encoder';
-import {createDimensinalityReducingWorker, IReduceDimensionalityResult 
+import {createDimensinalityReducingWorker, IReduceDimensionalityResult,
 } from '@datagrok-libraries/ml/src/workers/dimensionality-reducing-worker-creator';
 import {StringMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
-import {Coordinates} from '@datagrok-libraries/utils/src/type-declarations';
 import * as C from '../utils/constants';
+import {PeptidesModel} from '../model';
 
 export class PeptideSpaceViewer extends DG.JsViewer {
   method: string;
   measure: string;
   cyclesCount: number;
-  // controller: PeptidesController | null = null;
   customProperties = new Set(['method', 'measure', 'cyclesCount']);
   isEmbeddingCreating: boolean = false;
+  model!: PeptidesModel;
+  //FIXME: even if the property stays the same, for some reason it's still triggering prop change
+  prevProps!: {'method': string, 'measure': string, 'cyclesCount': number};
 
   constructor() {
     super();
@@ -28,34 +30,74 @@ export class PeptideSpaceViewer extends DG.JsViewer {
     const measureChoices = ['Levenshtein', 'Jaro-Winkler'];
     this.measure = this.addProperty('measure', DG.TYPE.STRING, 'Levenshtein', {choices: measureChoices});
     this.cyclesCount = this.addProperty('cyclesCount', DG.TYPE.INT, 100);
+    this.updatePrevProperties();
   }
 
-  async onFrameAttached(dataFrame: DG.DataFrame): Promise<void> {
-    super.onFrameAttached(dataFrame);
-    await this.render(this.dataFrame.temp[C.EMBEDDING_STATUS]);
+  updatePrevProperties(): void {
+    this.prevProps = {'method': this.method, 'measure': this.measure, 'cyclesCount': this.cyclesCount};
+  }
+
+  async onTableAttached(): Promise<void> {
+    super.onTableAttached();
+
+    this.model = await PeptidesModel.getInstance(this.dataFrame);
+
+    await this.render(!this.dataFrame.temp[C.EMBEDDING_STATUS]);
   }
 
   async onPropertyChanged(property: DG.Property | null): Promise<void> {
     super.onPropertyChanged(property);
+    if (this.prevProps[property?.name as 'method' | 'measure' | 'cyclesCount' ?? ''] == property?.get(this))
+      return;
 
+    if (this.model)
+      await this.render(this.customProperties.has(property?.name ?? '') || !this.dataFrame.temp[C.EMBEDDING_STATUS]);
 
-    await this.render(this.customProperties.has(property?.name ?? '') || this.dataFrame.temp[C.EMBEDDING_STATUS]);
+    this.updatePrevProperties();
   }
 
   async render(computeData=false): Promise<void> {
-    if (computeData && !this.isEmbeddingCreating) {
+    if (computeData && !this.isEmbeddingCreating && !this.model.isChangingEdfBitset) {
       this.isEmbeddingCreating = true;
       $(this.root).empty();
       const viewerHost = ui.waitBox(async () => {
-        await computeWeights(this.dataFrame, this.method, this.measure, this.cyclesCount);
+        const aligendSeqCol = this.dataFrame.columns.bySemType(C.SEM_TYPES.MACROMOLECULE)!;
+        const edf = await computeWeights(this.dataFrame, this.method, this.measure, this.cyclesCount, aligendSeqCol);
+        this.dataFrame.temp[C.EMBEDDING_STATUS] = true;
+        this.model.edf = edf;
+
+        if (edf === null)
+          return ui.label('Could not compute embeddings');
+
+        const edfSelection = edf.selection;
+        edfSelection.copyFrom(this.dataFrame.selection);
+        edfSelection.onChanged.subscribe(() => {
+          if (!this.model.isChangingEdfBitset)
+            this.model.fireBitsetChanged(true);
+        });
+
+        const colorCol = this.dataFrame.columns.bySemType(C.SEM_TYPES.ACTIVITY_SCALED)!;
+        edf.columns.add(colorCol);
 
-        const colorColName = this.dataFrame.columns.bySemType(C.SEM_TYPES.ACTIVITY_SCALED)!.name;
         const viewerOptions = {
-          x: '~X', y: '~Y', color: colorColName ?? '~MW', size: '~MW', title: 'Peptide Space',
+          x: '~X', y: '~Y', color: colorCol.name ?? '~MW', size: '~MW', title: 'Peptide Space',
           showYSelector: false, showXSelector: false, showColorSelector: false, showSizeSelector: false,
           zoomAndFilter: 'no action', axesFollowFilter: false,
         };
-        const viewerRoot = this.dataFrame.plot.scatter(viewerOptions).root;
+        const scatterPlot = edf.plot.scatter(viewerOptions);
+        const viewerRoot = scatterPlot.root;
+
+        viewerRoot.addEventListener('mousemove', (ev) => {
+          const idx = scatterPlot.hitTest(ev.offsetX, ev.offsetY);
+          if (idx != -1) {
+            const table = ui.tableFromMap({
+              'Activity': colorCol.get(idx),
+              'Sequence': aligendSeqCol.get(idx),
+              'Row ID': idx,
+            });
+            ui.tooltip.show(table, ev.clientX, ev.clientY);
+          }
+        });
         viewerRoot.style.width = 'auto';
         this.isEmbeddingCreating = false;
         viewerHost.style.paddingLeft = 'unset';
@@ -67,22 +109,22 @@ export class PeptideSpaceViewer extends DG.JsViewer {
   }
 }
 
+//Do not accept table, only column
 export async function computeWeights(
   table: DG.DataFrame, method: string, measure: string, cyclesCount: number, col?: DG.Column,
-): Promise<void> {
+): Promise<DG.DataFrame | null> {
   const pi = DG.TaskBarProgressIndicator.create('Creating embedding...');
+  let edf: DG.DataFrame | null = null;
   try {
     const axesNames = ['~X', '~Y', '~MW'];
-    col ??= table.columns.bySemType(C.SEM_TYPES.ALIGNED_SEQUENCE)!;
-    const columnData = col.toList()
-      .map((v) => AlignedSequenceEncoder.clean(v));
+    col ??= table.columns.bySemType(C.SEM_TYPES.MACROMOLECULE)!;
+    const columnData = col.toList().map((v) => AlignedSequenceEncoder.clean(v));
 
     const reduceDimRes: IReduceDimensionalityResult = await createDimensinalityReducingWorker(
       {data: columnData, metric: measure as StringMetrics}, method, {cycles: cyclesCount});
     const embcols = reduceDimRes.embedding;
 
-    const columns = Array.from(
-      embcols as Coordinates, (v: Float32Array, k) => DG.Column.fromFloat32Array(axesNames[k], v));
+    const columns = Array.from(embcols, (v: Float32Array, k) => DG.Column.fromFloat32Array(axesNames[k], v));
 
     function _getMW(sequences: string[]): Float32Array {
       const mw: Float32Array = new Float32Array(sequences.length);
@@ -94,27 +136,12 @@ export async function computeWeights(
 
     columns.push(DG.Column.fromFloat32Array('~MW', _getMW(columnData)));
 
-    const edf = DG.DataFrame.fromColumns(columns);
-
-    // Add new axes.
-    for (const axis of axesNames) {
-      const col = table.col(axis);
-      const newCol = edf.getCol(axis);
-
-      // if (col != null) {
-      //   for (let i = 0; i < newCol.length; ++i) {
-      //     const v = newCol.get(i);
-      //     table.set(axis, i, v);
-      //   }
-      // } else
-      //   table.columns.insert(newCol);
-      const columnList = table.columns;
-      col !== null ? columnList.replace(col, newCol) : columnList.insert(newCol);
-    }
+    edf = DG.DataFrame.fromColumns(columns);
   } catch (error) {
     grok.shell.error('Could not compute embeddings. See console for details.');
     console.error(error);
   } finally {
     pi.close();
+    return edf;
   }
 }

package/src/viewers/sar-viewer.ts

@@ -17,7 +17,7 @@ export class SARViewerBase extends DG.JsViewer {
   bidirectionalAnalysis: boolean;
   showSubstitution: boolean;
   maxSubstitutions: number;
-  activityLimit: number;
+  minActivityDelta: number;
   _titleHost = ui.divText('SAR Viewer', {id: 'pep-viewer-title'});
   initialized = false;
   isPropertyChanging: boolean = false;
@@ -28,18 +28,27 @@ export class SARViewerBase extends DG.JsViewer {
     this.scaling = this.string('scaling', 'none', {choices: ['none', 'lg', '-lg']});
     this.bidirectionalAnalysis = this.bool('bidirectionalAnalysis', false);
     this.showSubstitution = this.bool('showSubstitution', true);
-    this.maxSubstitutions = this.int('maxSubstitutions', 1);
-    this.activityLimit = this.float('activityLimit', 2);
+    this.maxSubstitutions = this.int('maxSubstitutions', 2);
+    this.minActivityDelta = this.float('minActivityDelta', 1);
   }
 
   async onTableAttached(): Promise<void> {
     super.onTableAttached();
-    this.dataFrame.temp[this.tempName] ??= this;
     this.sourceGrid = this.view?.grid ?? (grok.shell.v as DG.TableView).grid;
     this.model = await PeptidesModel.getInstance(this.dataFrame);
     // this.model.init(this.dataFrame);
-    await this.requestDataUpdate();
     this.helpUrl = '/help/domains/bio/peptides.md';
+    // await this.requestDataUpdate();
+
+    this.initProperties();
+  }
+
+  initProperties() {
+    const props = this.model.usedProperties;
+    IS_PROPERTY_CHANGING = true;
+    for (const [propName, propVal] of Object.entries(props))
+      this.props.set(propName, propVal as any as object);
+    IS_PROPERTY_CHANGING = false;
   }
 
   detach(): void {this.subs.forEach((sub) => sub.unsubscribe());}
@@ -56,12 +65,12 @@ export class SARViewerBase extends DG.JsViewer {
     this.viewerGrid?.invalidate();
   }
 
-  async requestDataUpdate(): Promise<void> {
-    await this.model.updateData(this.scaling, this.sourceGrid, this.bidirectionalAnalysis,
-      this.activityLimit, this.maxSubstitutions, this.showSubstitution);
-  }
+  // async requestDataUpdate(): Promise<void> {
+  //   await this.model.updateData(this.scaling, this.sourceGrid, this.bidirectionalAnalysis,
+  //     this.minActivityDelta, this.maxSubstitutions, this.showSubstitution);
+  // }
 
-  async onPropertyChanged(property: DG.Property): Promise<void> {
+  onPropertyChanged(property: DG.Property): void {
     super.onPropertyChanged(property);
     this.dataFrame.tags[property.name] = `${property.get(this)}`;
     if (!this.initialized || IS_PROPERTY_CHANGING)
@@ -71,7 +80,6 @@ export class SARViewerBase extends DG.JsViewer {
 
     if (propName === 'scaling' && typeof this.dataFrame !== 'undefined') {
       const activityCol = this.dataFrame.columns.bySemType(C.SEM_TYPES.ACTIVITY)!;
-      // const minActivity = this.dataFrame.getCol(C.COLUMNS_NAMES.ACTIVITY).stats.min;
       const minActivity = activityCol.stats.min;
       if (minActivity && minActivity <= 0 && this.scaling !== 'none') {
         grok.shell.warning(`Could not apply ${this.scaling}: ` +
@@ -84,7 +92,8 @@ export class SARViewerBase extends DG.JsViewer {
     if (!this.showSubstitution && ['maxSubstitutions', 'activityLimit'].includes(propName))
       return;
 
-    await this.requestDataUpdate();
+    // await this.requestDataUpdate();
+    this.model.updateDefault();
     this.render(true);
   }
 }
@@ -95,7 +104,6 @@ export class SARViewerBase extends DG.JsViewer {
 export class SARViewer extends SARViewerBase {
   _titleHost = ui.divText('Monomer-Positions', {id: 'pep-viewer-title'});
   _name = 'Structure-Activity Relationship';
-  tempName = 'sarViewer';
 
   constructor() {super();}
 
@@ -103,13 +111,16 @@ export class SARViewer extends SARViewerBase {
 
   async onTableAttached(): Promise<void> {
     await super.onTableAttached();
-    this.viewerGrid = this.model._sarGrid;
+    this.model.sarViewer ??= this;
+    // this.dataFrame.temp['sarViewer'] = this;
 
     this.subs.push(this.model.onSARGridChanged.subscribe((data) => {
       this.viewerGrid = data;
       this.render();
     }));
 
+    this.model.updateDefault();
+    this.viewerGrid = this.model._sarGrid;
     this.initialized = true;
     this.render();
   }
@@ -117,11 +128,11 @@ export class SARViewer extends SARViewerBase {
   isInitialized(): DG.Grid {return this.model?._sarGrid;}
 
   //1. debouncing in rxjs; 2. flags?
-  async onPropertyChanged(property: DG.Property): Promise<void> {
+  onPropertyChanged(property: DG.Property): void {
     if (!this.isInitialized() || IS_PROPERTY_CHANGING)
       return;
 
-    await super.onPropertyChanged(property);
+    super.onPropertyChanged(property);
     IS_PROPERTY_CHANGING = true;
     this.model.syncProperties(true);
     IS_PROPERTY_CHANGING = false;
@@ -132,7 +143,6 @@ export class SARViewer extends SARViewerBase {
 export class SARViewerVertical extends SARViewerBase {
   _name = 'Sequence-Activity relationship';
   _titleHost = ui.divText('Most Potent Residues', {id: 'pep-viewer-title'});
-  tempName = 'sarViewerVertical';
 
   constructor() {
     super();
@@ -142,24 +152,27 @@ export class SARViewerVertical extends SARViewerBase {
 
   async onTableAttached(): Promise<void> {
     await super.onTableAttached();
-    this.viewerGrid = this.model._sarVGrid;
+    this.model.sarViewerVertical ??= this;
 
     this.subs.push(this.model.onSARVGridChanged.subscribe((data) => {
       this.viewerGrid = data;
       this.render();
     }));
 
+    this.model.updateDefault();
+    this.viewerGrid = this.model._sarVGrid;
+
     this.initialized = true;
     this.render();
   }
 
   isInitialized(): DG.Grid {return this.model?._sarVGrid;}
 
-  async onPropertyChanged(property: DG.Property): Promise<void> {
+  onPropertyChanged(property: DG.Property): void {
     if (!this.isInitialized() || IS_PROPERTY_CHANGING)
       return;
 
-    await super.onPropertyChanged(property);
+    super.onPropertyChanged(property);
     IS_PROPERTY_CHANGING = true;
     this.model.syncProperties(false);
     IS_PROPERTY_CHANGING = false;

package/src/widgets/analyze-peptides.ts

@@ -1,11 +1,15 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+
+import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+
 import '../styles.css';
 import * as C from '../utils/constants';
-import {getSeparator} from '../utils/misc';
 import {PeptidesModel} from '../model';
 import {_package} from '../package';
+import $ from 'cash-dom';
+import {scaleActivity} from '../utils/misc';
 
 /** Peptide analysis widget.
  *
@@ -13,11 +17,12 @@ import {_package} from '../package';
  * @param {DG.Column} col Aligned sequence column
  * @return {Promise<DG.Widget>} Widget containing peptide analysis */
 export async function analyzePeptidesWidget(currentDf: DG.DataFrame, col: DG.Column): Promise<DG.Widget> {
+  const funcs = DG.Func.find({package: 'Bio', name: 'webLogoViewer'});
+  if (funcs.length == 0)
+    return new DG.Widget(ui.label('Bio package is missing or out of date. Please install the latest version.'));
   let tempCol = null;
   let scaledDf: DG.DataFrame;
   let newScaledColName: string;
-  const separator = getSeparator(col);
-  col.tags[C.TAGS.SEPARATOR] ??= separator;
 
   for (const column of currentDf.columns.numerical)
     tempCol = column.type === DG.TYPE.FLOAT ? column : null;
@@ -30,8 +35,7 @@ export async function analyzePeptidesWidget(currentDf: DG.DataFrame, col: DG.Col
     async (currentMethod: string): Promise<void> => {
       const currentActivityCol = activityColumnChoice.value?.name;
 
-      [scaledDf, newScaledColName] = await PeptidesModel.scaleActivity(
-        currentMethod, currentDf, currentActivityCol, true);
+      [scaledDf, newScaledColName] = scaleActivity(currentMethod, currentDf, currentActivityCol, true);
 
       const hist = scaledDf.plot.histogram({
         filteringEnabled: false,
@@ -63,12 +67,14 @@ export async function analyzePeptidesWidget(currentDf: DG.DataFrame, col: DG.Col
   });
   startBtn.style.alignSelf = 'center';
 
-  const viewer = await currentDf.plot.fromType('WebLogo');
+  const viewer = await currentDf.plot.fromType('WebLogo') as WebLogo;
   viewer.root.style.setProperty('height', '130px');
+  const logoHost = ui.div();
+  $(logoHost).empty().append(viewer.root);
 
   return new DG.Widget(
     ui.divV([
-      viewer.root,
+      logoHost,
       ui.splitH([
         ui.splitV([ui.inputs(inputsList), startBtn]),
         histogramHost,
@@ -95,10 +101,20 @@ export async function startAnalysis(
     activityScaledCol.semType = C.SEM_TYPES.ACTIVITY_SCALED;
     newDf.columns.add(activityScaledCol);
     newDf.name = 'Peptides analysis';
-    newDf.temp[C.COLUMNS_NAMES.ACTIVITY_SCALED] = newScaledColName;
-    newDf.tags[C.PEPTIDES_ANALYSIS] = 'true';
+    newDf.tags[C.COLUMNS_NAMES.ACTIVITY_SCALED] = newScaledColName;
+    // newDf.tags[C.PEPTIDES_ANALYSIS] = 'true';
+
+    const alignedSeqColUnits = alignedSeqCol.getTag(DG.TAGS.UNITS);
+    let monomerType = 'HELM_AA';
+    if (alignedSeqColUnits == 'HELM') {
+      const sampleSeq = alignedSeqCol.get(0)!;
+      monomerType = sampleSeq.startsWith('PEPTIDE') ? 'HELM_AA' : 'HELM_BASE';
+    } else {
+      monomerType = alignedSeqColUnits.split(':')[2] == 'PT' ? 'HELM_AA' : 'HELM_BASE';
+    }
+    newDf.setTag('monomerType', monomerType);
 
-    model = await PeptidesModel.getInstance(newDf, dgPackage ?? _package);
+    model = await PeptidesModel.getInstance(newDf);
   } else
     grok.shell.error('The activity column must be of floating point number type!');
   progress.close();