Issue #2: biomatrix and membrane transformation are applied

First biomatrix transformation must be applied on a chain - if there is one.
Membrane transformation be the next one.

* DescriptorCache added to handle color theme cases when a model
  loaded with descriptor, then later loaded with no descriptor
  (e.g.: from an external file).

* DebugUtils modul added to help discoveries in case of structure and
  transformation issues.

* TMDET color theme used as a preset in the props module.

src/apps/tm-viewer/index.html

@@ -91,9 +91,9 @@
             }
 
             let idList = [
+                '1afo', // TODO: something is wrong with the rotation
                 '1a0s', // TODO: wrong rotation
                 '2atk', // PASSED
-                '1afo', // TODO: something is wrong with the rotation
                 '1xl4', // PASSED
                 '1xl6', // PASSED
                 '4x8a', // TODO: something is very wrong with membrane planes

src/apps/tm-viewer/index.ts

@@ -24,6 +24,7 @@ export { PLUGIN_VERSION as version } from '../../mol-plugin/version';
 export { setDebugMode, setProductionMode } from '../../mol-util/debug';
 export { loadWithUNITMPMembraneRepresentation } from '../../extensions/tmdet/behavior';
 export { loadInitialSnapshot } from '../../extensions/tmdet/camera';
+export { DebugUtil } from '../../extensions/tmdet/debug-utils';
 
 const Extensions = {
     'tmdet-membrane-orientation': PluginSpec.Behavior(TMDETMembraneOrientation)

src/extensions/tmdet/algorithm.ts

@@ -9,14 +9,11 @@ import { Vec3 } from '../../mol-math/linear-algebra';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import '../../mol-util/polyfill';
 
-export const MEMBRANE_STORAGE_KEY = 'MEMBRANE_STORAGE_KEY';
-
 export const TMDETParams = {
     numberOfSpherePoints: PD.Numeric(140, { min: 35, max: 700, step: 1 }, { description: 'Number of spheres/directions to test for membrane placement. Original value is 350.' }),
     stepSize: PD.Numeric(1, { min: 0.25, max: 4, step: 0.25 }, { description: 'Thickness of membrane slices that will be tested' }),
     minThickness: PD.Numeric(20, { min: 10, max: 30, step: 1}, { description: 'Minimum membrane thickness used during refinement' }),
     maxThickness: PD.Numeric(40, { min: 30, max: 50, step: 1}, { description: 'Maximum membrane thickness used during refinement' }),
-    asaCutoff: PD.Numeric(40, { min: 10, max: 100, step: 1 }, { description: 'Relative ASA cutoff above which residues will be considered' }),
     adjust: PD.Numeric(14, { min: 0, max: 30, step: 1 }, { description: 'Minimum length of membrane-spanning regions (original values: 14 for alpha-helices and 5 for beta sheets). Set to 0 to not optimize membrane thickness.' }),
 };
 export type TMDETParams = typeof TMDETParams

src/extensions/tmdet/behavior.ts

@@ -7,12 +7,11 @@
 
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { StructureRepresentationPresetProvider, PresetStructureRepresentations } from '../../mol-plugin-state/builder/structure/representation-preset';
-import { MembraneOrientationProvider, MembraneOrientation } from './prop';
+import { MembraneOrientationProvider, MembraneOrientation, TmDetDescriptorCache } from './prop';
 import { StateObject, StateObjectRef, StateObjectCell, StateTransformer, StateTransform } from '../../mol-state';
 import { Task } from '../../mol-task';
 import { PluginBehavior } from '../../mol-plugin/behavior';
 import { MembraneOrientationRepresentationProvider, MembraneOrientationParams, MembraneOrientationRepresentation } from './representation';
-import { HydrophobicityColorThemeProvider } from '../../mol-theme/color/hydrophobicity';
 import { PluginStateObject, PluginStateTransform } from '../../mol-plugin-state/objects';
 import { PluginContext } from '../../mol-plugin/context';
 import { DefaultQueryRuntimeTable } from '../../mol-script/runtime/query/compiler';
@@ -25,8 +24,7 @@ import { ComponentsType, PDBTMDescriptor, PMS } from './types';
 import { registerTmDetSymmetry } from './symmetry';
 import { StripedResidues } from './coloring';
 import { TmDetColorThemeProvider } from './tmdet-color-theme';
-import { storeCameraSnapshot } from './camera';
-// import { loadInitialSnapshot, rotateCamera, storeCameraSnapshot } from './camera';
+import { rotateCamera, storeCameraSnapshot } from './camera'; // loadInitialSnapshot
 
 const Tag = MembraneOrientation.Tag;
 const TMDET_MEMBRANE_ORIENTATION = 'Membrane Orientation';
@@ -109,14 +107,26 @@ export const isTransmembrane = StructureSelectionQuery('Residues Embedded in Mem
     }
 });
 
+
+
+
+
+
+
+
+
 // //////////////////////////// TMDET VIEWER FUNCTIONS
 
+
+
+
 export let membraneOrientation: MembraneOrientation;
 
 export async function loadWithUNITMPMembraneRepresentation(plugin: PluginUIContext, params: any) {
     storeCameraSnapshot(plugin);
 
-    const pdbtmDescriptor = await downloadRegionDescriptor(plugin, params);
+    const pdbtmDescriptor: PDBTMDescriptor = await downloadRegionDescriptor(plugin, params);
+    TmDetDescriptorCache.add(pdbtmDescriptor);
 
     membraneOrientation = createMembraneOrientation(pdbtmDescriptor);
 
@@ -125,7 +135,7 @@ export async function loadWithUNITMPMembraneRepresentation(plugin: PluginUIConte
     // cartoon, colors etc.
     await createStructureRepresentation(plugin, pdbtmDescriptor);
 
-    //rotateCamera(plugin);
+    rotateCamera(plugin);
     //
     // reset the camera because the membranes render 1st and the structure might not be fully visible
     //
@@ -192,10 +202,27 @@ async function loadStructure(ctx: PluginUIContext, params: any, pdbtmDescriptor:
         trajectory, 'default', { representationPreset: 'preset-membrane-orientation' as any });
 }
 
+
+
+
+
+
 // //////////////////////////// END OF TMDET VIEWER SECTION
 
 //
 
+
+
+
+
+
+
+
+
+
+
+
+
 type MembraneOrientation3DType = typeof MembraneOrientation3D
 const MembraneOrientation3D = PluginStateTransform.BuiltIn({
     name: Tag.Representation,
@@ -258,8 +285,7 @@ export const MembraneOrientationPreset = StructureRepresentationPresetProvider({
         }
 
         const membraneOrientation = await tryCreateMembraneOrientation(plugin, structureCell);
-        // TODO: change colorTheme!!!
-        const colorTheme = HydrophobicityColorThemeProvider.name as any;
+        const colorTheme =  TmDetColorThemeProvider.name as any;
         const preset = await PresetStructureRepresentations.auto.apply(ref, { ...params, theme: { globalName: colorTheme, focus: { name: colorTheme } } }, plugin);
 
         return { components: preset.components, representations: { ...preset.representations, membraneOrientation } };

src/extensions/tmdet/debug-utils.ts

@@ -0,0 +1,84 @@
+import { mmCIF_Database } from "../../mol-io/reader/cif/schema/mmcif";
+import { Mat4, Vec3 } from "../../mol-math/linear-algebra";
+import { MmcifFormat } from "../../mol-model-formats/structure/mmcif";
+import { Model } from "../../mol-model/structure";
+import { AtomicConformation } from "../../mol-model/structure/model/properties/atomic";
+import { PluginUIContext } from "../../mol-plugin-ui/context";
+import { transformationForStateTransform } from "./transformation";
+import { PDBTMTransformationMatrix } from "./types";
+
+export namespace DebugUtil {
+    let plugin: PluginUIContext;
+
+    export function init(ctx: PluginUIContext) {
+        plugin = ctx;
+    }
+
+    export function transformVector(v: Vec3, matrix: Mat4): Vec3 {
+        const result = Vec3.transformMat4(Vec3(), v, matrix);
+        console.log("transformVector: Input v & matrix:", v, Mat4.makeTable(matrix));
+        console.log("transformVector: Result vector:", result);
+        return result;
+    }
+
+    export function descriptorMxToMat4(matrix: PDBTMTransformationMatrix): Mat4 {
+        console.log("descriptorMxToMat4: Input:", matrix);
+        const result = transformationForStateTransform(matrix);
+        console.log("descriptorMxToMat4: Result:", result);
+        return result;
+    }
+
+
+    //
+    // structure utils
+    //
+
+
+    export function getCellOfFirstStructure() {
+        return plugin.managers.structure.hierarchy.current.models[0].structures[0].cell;
+    }
+
+    export function getModelOfFirstStructure() {
+        return getCellOfFirstStructure().obj?.data.model;
+    }
+
+    // in case of mmCIF format
+    export function dumpAtomProperties(authAtomId: number) {
+        const model: Model|undefined = getModelOfFirstStructure();
+        console.log("First model:", model);
+        if(!model) {
+            return;
+        }
+
+        const rowCount = model.atomicHierarchy.atoms._rowCount;
+        const conformation: AtomicConformation = model.atomicConformation;
+        const db: mmCIF_Database = (model.sourceData as MmcifFormat).data.db;
+        const atom_site = db.atom_site;
+        for (let index = 0; index < rowCount; index++) {
+            if (conformation.atomId.value(index) == authAtomId) {
+                console.log("Model Atom Conformation:", {
+                    atomIdParameter: authAtomId,
+                    atomId: conformation.atomId.value(index),
+                    coords: [
+                        conformation.x[index],
+                        conformation.y[index],
+                        conformation.z[index]
+                    ],
+                    xyzDefined: conformation.xyzDefined
+                });
+
+                console.log("Atom Source Data (mmCIF database):", {
+                    authId: atom_site.auth_atom_id.value(index),
+                    compId: atom_site.auth_comp_id.value(index),
+                    authAsymId: atom_site.auth_asym_id.value(index),
+                    authSeqId: atom_site.auth_seq_id.value(index),
+                    coords: [
+                        atom_site.Cartn_x.value(index),
+                        atom_site.Cartn_y.value(index),
+                        atom_site.Cartn_z.value(index)
+                    ]
+                });
+            }
+        }
+    }
+}

src/extensions/tmdet/prop.ts

@@ -16,6 +16,7 @@ import { QuerySymbolRuntime } from '../../mol-script/runtime/query/base';
 import { CustomPropSymbol } from '../../mol-script/language/symbol';
 import { Type } from '../../mol-script/language/type';
 import { membraneOrientation } from './behavior';
+import { PDBTMDescriptor } from './types';
 
 export const MembraneOrientationParams = {
     ...TMDETParams
@@ -25,6 +26,33 @@ export type MembraneOrientationProps = PD.Values<MembraneOrientationParams>
 
 export { MembraneOrientation };
 
+/**
+ * Simple storage to made PDBTM descriptor available globally.
+ *
+ * @author Csongor Gerdan <gerdan.csongor@ttk.hu>
+ */
+class DescriptorCache {
+    private map: Map<string, PDBTMDescriptor>;
+
+    constructor() {
+        this.map = new Map<string, PDBTMDescriptor>();
+    }
+
+    add(descriptor: PDBTMDescriptor) {
+        const key = descriptor.pdb_id.toLowerCase();
+        if (!this.map.has(key)) {
+            this.map.set(key, descriptor);
+        }
+    }
+
+    get(key: string) {
+        key = key.toLowerCase();
+        return this.map.get(key);
+    }
+
+}
+export const TmDetDescriptorCache = new DescriptorCache();
+
 interface MembraneOrientation {
     // point in membrane boundary
     readonly planePoint1: Vec3,

src/extensions/tmdet/tmdet-color-theme.ts

@@ -6,6 +6,7 @@ import { ColorNames } from '../../mol-util/color/names';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { Location } from '../../mol-model/location';
 import { PDBTMChain } from './types';
+import { TmDetDescriptorCache } from './prop';
 
 
 export type TmDetColorThemeParams = {
@@ -16,9 +17,20 @@ export function TmDetColorTheme(
     ctx: ThemeDataContext,
     props: PD.Values<TmDetColorThemeParams>
 ): ColorTheme<TmDetColorThemeParams> {
-    console.log('ColorTheme CTX', ctx);
-    const descriptorChains = props.pdbtmDescriptor.chains as PDBTMChain[];
-    console.log('ColorTheme PROPS', descriptorChains);
+    let descriptorChains: PDBTMChain[] = [];
+    let pdbtmDescriptor = props.pdbtmDescriptor;
+    // If it is not given as parameter,
+    // but there is one in the cache for this structure.
+    if (!pdbtmDescriptor) {
+        const pdbId = ctx.structure?.model.entryId;
+        if (pdbId) {
+            pdbtmDescriptor = TmDetDescriptorCache.get(pdbId);
+        }
+    }
+    if (pdbtmDescriptor) {
+        descriptorChains = pdbtmDescriptor.chains;
+    }
+    console.log('TmDetColorTheme dataCtx & chains', ctx, descriptorChains);
 
     return {
         factory: TmDetColorTheme,
@@ -108,7 +120,7 @@ export const TmDetColorThemeProvider: ColorTheme.Provider<TmDetColorThemeParams,
     label: 'TMDet Topology Theme',
     category: 'TMDet',
     factory: TmDetColorTheme,
-    getParams: () => ({ pdbtmDescriptor: { isOptional: true } }),
+    getParams: (ctx: ThemeDataContext) => ({ pdbtmDescriptor: { isOptional: true } }),
     defaultValues: { pdbtmDescriptor: undefined },
     isApplicable: () => true,
 };

src/extensions/tmdet/transformation.ts

@@ -9,23 +9,37 @@ import { Expression } from '../../mol-script/language/expression';
 import { MembraneOrientation } from './prop';
 import { TmDetColorThemeProvider } from './tmdet-color-theme';
 
-export async function applyTransformations(ctx: PluginUIContext, pdbtmDescriptor: PDBTMDescriptor) {
+export async function applyTransformations(plugin: PluginUIContext, pdbtmDescriptor: PDBTMDescriptor) {
     const annotations = pdbtmDescriptor.additional_entry_annotations;
 
     console.log('BIOMX', annotations.biomatrix);
-    if (annotations.biomatrix == undefined) {
-        return;
+    if (annotations.biomatrix) {
+        annotations.biomatrix.matrix_list.forEach(function(mx) {
+            mx.apply_to_chain_list.forEach(function(chainPair) {
+                let id  = chainPair.chain_id;
+                chainTransformation(plugin, pdbtmDescriptor, mx.transformation_matrix, id);
+            });
+        });
     }
 
-    annotations.biomatrix.matrix_list.forEach(function(mx) {
-        mx.apply_to_chain_list.forEach(function(chainPair) {
-            let id  = chainPair.chain_id;
-            let newId = chainPair.new_chain_id;
-            console.log(`before RED ${id} -> ${newId}`);
-            chainTransformation(ctx, pdbtmDescriptor, mx.transformation_matrix, id);
-            console.log("after RED");
-        });
-    });
+    // membrane transformation
+    const membraneTransformation = transformationForStateTransform(pdbtmDescriptor.additional_entry_annotations.membrane.transformation_matrix);
+    const structure: StateObjectRef<PMS> = plugin.managers.structure.hierarchy.current.models[0].structures[0].cell;
+    const update: StateBuilder.To<any, any> = plugin.build().to(structure);
+
+    update
+        .apply(StateTransforms.Model.TransformStructureConformation, {
+            "transform": { name: "matrix", params: { data: membraneTransformation, transpose: false } }
+        })
+        .apply(
+            StateTransforms.Representation.StructureRepresentation3D,
+            createStructureRepresentationParams(plugin, structure.obj?.data, {
+                type: 'cartoon',
+                color: TmDetColorThemeProvider.name as any, colorParams: { pdbtmDescriptor }
+            })
+        );
+    update.commit();
+
 }
 
 /**
@@ -39,7 +53,7 @@ export async function applyTransformations(ctx: PluginUIContext, pdbtmDescriptor
  export function chainTransformation(plugin: PluginUIContext, pdbtmDescriptor: PDBTMDescriptor, transformationMatrix: PDBTMTransformationMatrix, chainId: string): void {
     const query: Expression = getChainExpression(chainId);
 
-    let transformation = transformationForStateTransform(transformationMatrix);
+    const transformation = transformationForStateTransform(transformationMatrix);
     const structure: StateObjectRef<PMS> = plugin.managers.structure.hierarchy.current.models[0].structures[0].cell;
     const update: StateBuilder.To<any, any> = plugin.build().to(structure);
 
@@ -70,42 +84,18 @@ function vneg(u: Vec3): Vec3 {
 }
 
 export function createMembraneOrientation(pdbtmDescriptor: PDBTMDescriptor): MembraneOrientation {
-    const annotations = pdbtmDescriptor.additional_entry_annotations;
-    const membrane = annotations.membrane;
-    const transformation: Mat4 = transformationForStateTransform(membrane.transformation_matrix);
-    const translation: Vec3 = Mat4.getTranslation(Vec3.zero(), transformation);
-
-    // TODO: console.log("MEMBRANE TRNASFORMATION:\n\n", Mat4.makeTable(transformation));
-    Vec3.negate(translation, translation);
-    Mat4.setTranslation(transformation, translation);
-    // TODO: console.log("MEMBRANE TRNASFORMATION: NEGATED trnltn:\n\n", Mat4.makeTable(transformation));
+    const membrane = pdbtmDescriptor.additional_entry_annotations.membrane;
 
-    // transpose rotation of transformation (inverse rotation)
-    Mat4.transpose(transformation, Mat4.extractRotation(transformation, transformation));
-    // TODO: console.log("MEMBRANE TRANSPOSED:\n\n", Mat4.makeTable(transformation));
-
-    // transform membrane normal
     const membraneNormal: Vec3 = Vec3.fromObj(membrane.normal);
-    Vec3.transformMat4(membraneNormal, membraneNormal, transformation);
-
     const result: MembraneOrientation = {
-        planePoint1: vadd(membraneNormal, translation),
-        planePoint2: vadd(vneg(membraneNormal), translation),
-        centroid: translation,
+        planePoint1: membraneNormal,
+        planePoint2: vneg(membraneNormal),
+        centroid: Vec3.zero(),
         normalVector: membraneNormal,
 
         // (NOTE: the TMDET extension calculates and sets it during applying preset)
         radius: membrane.radius
     };
-    // const result: MembraneOrientation = {
-    //     planePoint1: membraneNormal,
-    //     planePoint2: vneg(membraneNormal),
-    //     centroid: Vec3.zero(),
-    //     normalVector: membraneNormal,
-
-    //     // (NOTE: the TMDET extension calculates and sets it during applying preset)
-    //     radius: membrane.radius
-    // };
 
     return result;
 }