molstar
Version:
A comprehensive macromolecular library.
215 lines • 9.95 kB
JavaScript
/**
* Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
import { __assign, __awaiter, __generator } from "tslib";
import { symmetry_gql } from '../graphql/symmetry.gql';
import { ParamDefinition as PD } from '../../../mol-util/param-definition';
import { Model, StructureSelection, QueryContext } from '../../../mol-model/structure';
import { Column } from '../../../mol-data/db';
import { GraphQLClient } from '../../../mol-util/graphql-client';
import { CustomStructureProperty } from '../../../mol-model-props/common/custom-structure-property';
import { MmcifFormat } from '../../../mol-model-formats/structure/mmcif';
import { SetUtils } from '../../../mol-util/set';
import { MolScriptBuilder as MS } from '../../../mol-script/language/builder';
import { compile } from '../../../mol-script/runtime/query/compiler';
import { CustomPropertyDescriptor } from '../../../mol-model/custom-property';
var BiologicalAssemblyNames = new Set([
'author_and_software_defined_assembly',
'author_defined_assembly',
'complete icosahedral assembly',
'complete point assembly',
'representative helical assembly',
'software_defined_assembly'
]);
export function isBiologicalAssembly(structure) {
var _a;
if (!MmcifFormat.is(structure.models[0].sourceData))
return false;
var mmcif = structure.models[0].sourceData.data.db;
if (!mmcif.pdbx_struct_assembly.details.isDefined)
return false;
var id = ((_a = structure.units[0].conformation.operator.assembly) === null || _a === void 0 ? void 0 : _a.id) || '';
if (id === '')
return true;
var indices = Column.indicesOf(mmcif.pdbx_struct_assembly.id, function (e) { return e === id; });
if (indices.length !== 1)
return false;
var details = mmcif.pdbx_struct_assembly.details.value(indices[0]);
return BiologicalAssemblyNames.has(details);
}
export var AssemblySymmetry;
(function (AssemblySymmetry) {
var Tag;
(function (Tag) {
Tag["Cluster"] = "rcsb-assembly-symmetry-cluster";
Tag["Representation"] = "rcsb-assembly-symmetry-3d";
})(Tag = AssemblySymmetry.Tag || (AssemblySymmetry.Tag = {}));
AssemblySymmetry.DefaultServerUrl = 'https://data.rcsb.org/graphql';
function isApplicable(structure) {
return (!!structure && structure.models.length === 1 &&
Model.isFromPdbArchive(structure.models[0]) &&
isBiologicalAssembly(structure));
}
AssemblySymmetry.isApplicable = isApplicable;
function fetch(ctx, structure, props) {
var _a, _b;
return __awaiter(this, void 0, void 0, function () {
var client, variables, result, value;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
if (!isApplicable(structure))
return [2 /*return*/, { value: [] }];
client = new GraphQLClient(props.serverUrl, ctx.assetManager);
variables = {
assembly_id: ((_a = structure.units[0].conformation.operator.assembly) === null || _a === void 0 ? void 0 : _a.id) || '',
entry_id: structure.units[0].model.entryId
};
return [4 /*yield*/, client.request(ctx.runtime, symmetry_gql, variables)];
case 1:
result = _c.sent();
value = [];
if (!((_b = result.data.assembly) === null || _b === void 0 ? void 0 : _b.rcsb_struct_symmetry)) {
console.error('expected `rcsb_struct_symmetry` field');
}
else {
value = result.data.assembly.rcsb_struct_symmetry;
}
return [2 /*return*/, { value: value, assets: [result] }];
}
});
});
}
AssemblySymmetry.fetch = fetch;
/** Returns the index of the first non C1 symmetry or -1 */
function firstNonC1(assemblySymmetryData) {
for (var i = 0, il = assemblySymmetryData.length; i < il; ++i) {
if (assemblySymmetryData[i].symbol !== 'C1')
return i;
}
return -1;
}
AssemblySymmetry.firstNonC1 = firstNonC1;
function isRotationAxes(x) {
return !!x && x.length > 0;
}
AssemblySymmetry.isRotationAxes = isRotationAxes;
function getAsymIds(assemblySymmetry) {
var asymIds = new Set();
for (var _i = 0, _a = assemblySymmetry.clusters; _i < _a.length; _i++) {
var c = _a[_i];
if (!(c === null || c === void 0 ? void 0 : c.members))
continue;
for (var _b = 0, _c = c.members; _b < _c.length; _b++) {
var m = _c[_b];
if (m === null || m === void 0 ? void 0 : m.asym_id)
asymIds.add(m.asym_id);
}
}
return SetUtils.toArray(asymIds);
}
AssemblySymmetry.getAsymIds = getAsymIds;
function getAsymIdsStructure(structure, asymIds) {
var query = MS.struct.modifier.union([
MS.struct.generator.atomGroups({
'chain-test': MS.core.set.has([MS.set.apply(MS, asymIds), MS.ammp('label_asym_id')])
})
]);
var compiled = compile(query);
var result = compiled(new QueryContext(structure));
return StructureSelection.unionStructure(result);
}
/** Returns structure limited to all cluster member chains */
function getStructure(structure, assemblySymmetry) {
var asymIds = AssemblySymmetry.getAsymIds(assemblySymmetry);
return asymIds.length > 0 ? getAsymIdsStructure(structure, asymIds) : structure;
}
AssemblySymmetry.getStructure = getStructure;
})(AssemblySymmetry || (AssemblySymmetry = {}));
export function getSymmetrySelectParam(structure) {
var param = PD.Select(0, [[0, 'First Symmetry']]);
if (structure) {
var assemblySymmetryData = AssemblySymmetryDataProvider.get(structure).value;
if (assemblySymmetryData) {
var options = [
[-1, 'Off']
];
for (var i = 0, il = assemblySymmetryData.length; i < il; ++i) {
var _a = assemblySymmetryData[i], symbol = _a.symbol, kind = _a.kind;
if (symbol !== 'C1') {
options.push([i, i + 1 + ": " + symbol + " " + kind]);
}
}
if (options.length > 1) {
param.options = options;
param.defaultValue = options[1][0];
}
else {
options.length = 0;
}
}
}
return param;
}
//
export var AssemblySymmetryDataParams = {
serverUrl: PD.Text(AssemblySymmetry.DefaultServerUrl, { description: 'GraphQL endpoint URL' })
};
export var AssemblySymmetryDataProvider = CustomStructureProperty.createProvider({
label: 'Assembly Symmetry Data',
descriptor: CustomPropertyDescriptor({
name: 'rcsb_struct_symmetry_data',
// TODO `cifExport` and `symbol`
}),
type: 'root',
defaultParams: AssemblySymmetryDataParams,
getParams: function (data) { return AssemblySymmetryDataParams; },
isApplicable: function (data) { return AssemblySymmetry.isApplicable(data); },
obtain: function (ctx, data, props) { return __awaiter(void 0, void 0, void 0, function () {
var p;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
p = __assign(__assign({}, PD.getDefaultValues(AssemblySymmetryDataParams)), props);
return [4 /*yield*/, AssemblySymmetry.fetch(ctx, data, p)];
case 1: return [2 /*return*/, _a.sent()];
}
});
}); }
});
//
function getAssemblySymmetryParams(data) {
return __assign(__assign({}, AssemblySymmetryDataParams), { symmetryIndex: getSymmetrySelectParam(data) });
}
export var AssemblySymmetryParams = getAssemblySymmetryParams();
export var AssemblySymmetryProvider = CustomStructureProperty.createProvider({
label: 'Assembly Symmetry',
descriptor: CustomPropertyDescriptor({
name: 'rcsb_struct_symmetry',
// TODO `cifExport` and `symbol`
}),
type: 'root',
defaultParams: AssemblySymmetryParams,
getParams: getAssemblySymmetryParams,
isApplicable: function (data) { return AssemblySymmetry.isApplicable(data); },
obtain: function (ctx, data, props) { return __awaiter(void 0, void 0, void 0, function () {
var p, assemblySymmetryData, assemblySymmetry;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
p = __assign(__assign({}, PD.getDefaultValues(getAssemblySymmetryParams(data))), props);
return [4 /*yield*/, AssemblySymmetryDataProvider.attach(ctx, data, p)];
case 1:
_a.sent();
assemblySymmetryData = AssemblySymmetryDataProvider.get(data).value;
assemblySymmetry = assemblySymmetryData === null || assemblySymmetryData === void 0 ? void 0 : assemblySymmetryData[p.symmetryIndex];
if (!assemblySymmetry)
new Error("No assembly symmetry found for index " + p.symmetryIndex);
return [2 /*return*/, { value: assemblySymmetry }];
}
});
}); }
});
//# sourceMappingURL=prop.js.map