molstar
Version:
A comprehensive macromolecular library.
285 lines (284 loc) • 13.4 kB
JavaScript
/**
* Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author David Sehnal <david.sehnal@gmail.com>
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
import { __assign, __awaiter, __generator } from "tslib";
import { Column, Table } from '../../../mol-data/db';
import { toTable } from '../../../mol-io/reader/cif/schema';
import { mmCIF_residueId_schema } from '../../../mol-io/reader/cif/schema/mmcif-extras';
import { CifWriter } from '../../../mol-io/writer/cif';
import { Model, Unit, IndexedCustomProperty } from '../../../mol-model/structure';
import { residueIdFields } from '../../../mol-model/structure/export/categories/atom_site';
import { CustomPropSymbol } from '../../../mol-script/language/symbol';
import { Type } from '../../../mol-script/language/type';
import { QuerySymbolRuntime } from '../../../mol-script/runtime/query/compiler';
import { ParamDefinition as PD } from '../../../mol-util/param-definition';
import { arraySetAdd } from '../../../mol-util/array';
import { MmcifFormat } from '../../../mol-model-formats/structure/mmcif';
import { PropertyWrapper } from '../../../mol-model-props/common/wrapper';
import { CustomModelProperty } from '../../../mol-model-props/common/custom-model-property';
import { Asset } from '../../../mol-util/assets';
import { CustomPropertyDescriptor } from '../../../mol-model/custom-property';
export { StructureQualityReport };
var StructureQualityReport;
(function (StructureQualityReport) {
StructureQualityReport.DefaultServerUrl = 'https://www.ebi.ac.uk/pdbe/api/validation/residuewise_outlier_summary/entry/';
function getEntryUrl(pdbId, serverUrl) {
return "".concat(serverUrl, "/").concat(pdbId.toLowerCase());
}
StructureQualityReport.getEntryUrl = getEntryUrl;
function isApplicable(model) {
return !!model && Model.hasPdbId(model);
}
StructureQualityReport.isApplicable = isApplicable;
StructureQualityReport.Schema = {
pdbe_structure_quality_report: {
updated_datetime_utc: Column.Schema.str
},
pdbe_structure_quality_report_issues: __assign(__assign({ id: Column.Schema.int }, mmCIF_residueId_schema), { pdbx_PDB_model_num: Column.Schema.int, issue_type_group_id: Column.Schema.int }),
pdbe_structure_quality_report_issue_types: {
group_id: Column.Schema.int,
issue_type: Column.Schema.str
}
};
function fromJson(model, data) {
var info = PropertyWrapper.createInfo();
var issueMap = createIssueMapFromJson(model, data);
return { info: info, data: issueMap };
}
StructureQualityReport.fromJson = fromJson;
function fromServer(ctx, model, props) {
return __awaiter(this, void 0, void 0, function () {
var url, json, data;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
url = Asset.getUrlAsset(ctx.assetManager, getEntryUrl(model.entryId, props.serverUrl));
return [4 /*yield*/, ctx.assetManager.resolve(url, 'json').runInContext(ctx.runtime)];
case 1:
json = _a.sent();
data = json.data[model.entryId.toLowerCase()];
if (!data)
throw new Error('missing data');
return [2 /*return*/, { value: fromJson(model, data), assets: [json] }];
}
});
});
}
StructureQualityReport.fromServer = fromServer;
function fromCif(ctx, model, props) {
var info = PropertyWrapper.tryGetInfoFromCif('pdbe_structure_quality_report', model);
if (!info)
return;
var data = getCifData(model);
var issueMap = createIssueMapFromCif(model, data.residues, data.groups);
return { info: info, data: issueMap };
}
StructureQualityReport.fromCif = fromCif;
function fromCifOrServer(ctx, model, props) {
return __awaiter(this, void 0, void 0, function () {
var cif;
return __generator(this, function (_a) {
cif = fromCif(ctx, model, props);
return [2 /*return*/, cif ? { value: cif } : fromServer(ctx, model, props)];
});
});
}
StructureQualityReport.fromCifOrServer = fromCifOrServer;
var _emptyArray = [];
function getIssues(e) {
if (!Unit.isAtomic(e.unit))
return _emptyArray;
var prop = StructureQualityReportProvider.get(e.unit.model).value;
if (!prop || !prop.data)
return _emptyArray;
var rI = e.unit.residueIndex[e.element];
return prop.data.issues.has(rI) ? prop.data.issues.get(rI) : _emptyArray;
}
StructureQualityReport.getIssues = getIssues;
function getIssueTypes(structure) {
if (!structure)
return _emptyArray;
var prop = StructureQualityReportProvider.get(structure.models[0]).value;
if (!prop || !prop.data)
return _emptyArray;
return prop.data.issueTypes;
}
StructureQualityReport.getIssueTypes = getIssueTypes;
function getCifData(model) {
if (!MmcifFormat.is(model.sourceData))
throw new Error('Data format must be mmCIF.');
return {
residues: toTable(StructureQualityReport.Schema.pdbe_structure_quality_report_issues, model.sourceData.data.frame.categories.pdbe_structure_quality_report_issues),
groups: toTable(StructureQualityReport.Schema.pdbe_structure_quality_report_issue_types, model.sourceData.data.frame.categories.pdbe_structure_quality_report_issue_types),
};
}
})(StructureQualityReport || (StructureQualityReport = {}));
export var StructureQualityReportParams = {
serverUrl: PD.Text(StructureQualityReport.DefaultServerUrl, { description: 'JSON API Server URL' })
};
export var StructureQualityReportProvider = CustomModelProperty.createProvider({
label: 'Structure Quality Report',
descriptor: CustomPropertyDescriptor({
name: 'pdbe_structure_quality_report',
cifExport: {
prefix: 'pdbe',
context: function (ctx) {
return createExportContext(ctx);
},
categories: [
PropertyWrapper.defaultInfoCategory('pdbe_structure_quality_report', function (ctx) { return ctx.info; }),
{
name: 'pdbe_structure_quality_report_issues',
instance: function (ctx) {
return {
fields: _structure_quality_report_issues_fields,
source: ctx.models.map(function (data) { return ({ data: data, rowCount: data.elements.length }); })
};
}
}, {
name: 'pdbe_structure_quality_report_issue_types',
instance: function (ctx) {
return CifWriter.Category.ofTable(ctx.issueTypes);
}
}
]
},
symbols: {
issueCount: QuerySymbolRuntime.Dynamic(CustomPropSymbol('pdbe', 'structure-quality.issue-count', Type.Num), function (ctx) { return StructureQualityReport.getIssues(ctx.element).length; }),
// TODO: add (hasIssue :: IssueType(extends string) -> boolean) symbol
}
}),
type: 'static',
defaultParams: StructureQualityReportParams,
getParams: function (data) { return StructureQualityReportParams; },
isApplicable: function (data) { return StructureQualityReport.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(StructureQualityReportParams)), props);
return [4 /*yield*/, StructureQualityReport.fromCifOrServer(ctx, data, p)];
case 1: return [2 /*return*/, _a.sent()];
}
});
}); }
});
var _structure_quality_report_issues_fields = CifWriter.fields()
.index('id')
.many(residueIdFields(function (i, d) { return d.elements[i]; }, { includeModelNum: true }))
.int('issue_type_group_id', function (i, d) { return d.groupId[i]; })
.getFields();
function createExportContext(ctx) {
var groupMap = new Map();
var models = [];
var group_id = [], issue_type = [];
var info = PropertyWrapper.createInfo();
for (var _i = 0, _a = ctx.structures; _i < _a.length; _i++) {
var s = _a[_i];
var prop = StructureQualityReportProvider.get(s.model).value;
if (prop)
info = prop.info;
if (!prop || !prop.data)
continue;
var _b = prop.data.issues.getElements(s), elements = _b.elements, property = _b.property;
if (elements.length === 0)
continue;
var elementGroupId = [];
for (var i = 0; i < elements.length; i++) {
var issues = property(i);
var key = issues.join(',');
if (!groupMap.has(key)) {
var idx = groupMap.size + 1;
groupMap.set(key, idx);
for (var _c = 0, issues_1 = issues; _c < issues_1.length; _c++) {
var issue = issues_1[_c];
group_id.push(idx);
issue_type.push(issue);
}
}
elementGroupId[i] = groupMap.get(key);
}
models.push({ elements: elements, groupId: elementGroupId });
}
return {
info: info,
models: models,
issueTypes: Table.ofArrays(StructureQualityReport.Schema.pdbe_structure_quality_report_issue_types, { group_id: group_id, issue_type: issue_type })
};
}
function createIssueMapFromJson(modelData, data) {
var ret = new Map();
if (!data.molecules)
return;
var issueTypes = [];
for (var _i = 0, _a = data.molecules; _i < _a.length; _i++) {
var entity = _a[_i];
var entity_id = entity.entity_id.toString();
for (var _b = 0, _c = entity.chains; _b < _c.length; _b++) {
var chain = _c[_b];
var asym_id = chain.struct_asym_id.toString();
for (var _d = 0, _e = chain.models; _d < _e.length; _d++) {
var model = _e[_d];
var model_id = model.model_id.toString();
if (+model_id !== modelData.modelNum)
continue;
for (var _f = 0, _g = model.residues; _f < _g.length; _f++) {
var residue = _g[_f];
var auth_seq_id = residue.author_residue_number, ins_code = residue.author_insertion_code || '';
var idx = modelData.atomicHierarchy.index.findResidue(entity_id, asym_id, auth_seq_id, ins_code);
ret.set(idx, residue.outlier_types);
for (var _h = 0, _j = residue.outlier_types; _h < _j.length; _h++) {
var t = _j[_h];
arraySetAdd(issueTypes, t);
}
}
}
}
}
return {
issues: IndexedCustomProperty.fromResidueMap(ret),
issueTypes: issueTypes
};
}
function createIssueMapFromCif(modelData, residueData, groupData) {
var ret = new Map();
var label_entity_id = residueData.label_entity_id, label_asym_id = residueData.label_asym_id, auth_seq_id = residueData.auth_seq_id, pdbx_PDB_ins_code = residueData.pdbx_PDB_ins_code, issue_type_group_id = residueData.issue_type_group_id, pdbx_PDB_model_num = residueData.pdbx_PDB_model_num, _rowCount = residueData._rowCount;
var groups = parseIssueTypes(groupData);
for (var i = 0; i < _rowCount; i++) {
if (pdbx_PDB_model_num.value(i) !== modelData.modelNum)
continue;
var idx = modelData.atomicHierarchy.index.findResidue(label_entity_id.value(i), label_asym_id.value(i), auth_seq_id.value(i), pdbx_PDB_ins_code.value(i));
ret.set(idx, groups.get(issue_type_group_id.value(i)));
}
var issueTypes = [];
groups.forEach(function (issues) {
for (var _i = 0, issues_2 = issues; _i < issues_2.length; _i++) {
var t = issues_2[_i];
arraySetAdd(issueTypes, t);
}
});
return {
issues: IndexedCustomProperty.fromResidueMap(ret),
issueTypes: issueTypes
};
}
function parseIssueTypes(groupData) {
var ret = new Map();
var group_id = groupData.group_id, issue_type = groupData.issue_type;
for (var i = 0; i < groupData._rowCount; i++) {
var group = void 0;
var id = group_id.value(i);
if (ret.has(id))
group = ret.get(id);
else {
group = [];
ret.set(id, group);
}
group.push(issue_type.value(i));
}
return ret;
}