Current Dev State

static/js/ketcher2/script/chem/struct/sgforest.js

@@ -0,0 +1,164 @@
+/****************************************************************************
+ * Copyright 2017 EPAM Systems
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ ***************************************************************************/
+
+var Map = require('../../util/map');
+var Set = require('../../util/set');
+
+function SGroupForest(molecule) {
+	this.parent = new Map(); // child id -> parent id
+	this.children = new Map(); // parent id -> list of child ids
+	this.children.set(-1, []); // extra root node
+	this.molecule = molecule;
+}
+
+// returns an array or s-group ids in the order of breadth-first search
+SGroupForest.prototype.getSGroupsBFS = function () {
+	var order = [];
+	var id = -1;
+	var queue = [].slice.call(this.children.get(-1));
+	while (queue.length > 0) {
+		id = queue.shift();
+		queue = queue.concat(this.children.get(id));
+		order.push(id);
+	}
+	return order;
+};
+
+SGroupForest.prototype.getAtomSets = function () {
+	return this.molecule.sgroups.map(function (sgid, sgroup) {
+		return Set.fromList(sgroup.atoms);
+	});
+};
+
+SGroupForest.prototype.getAtomSetRelations = function (newId, atoms /* Set */) {
+	// find the lowest superset in the hierarchy
+	var isStrictSuperset = new Map();
+	var isSubset = new Map();
+	var atomSets = this.getAtomSets();
+	atomSets.unset(newId);
+	atomSets.each(function (id, atomSet) {
+		isSubset.set(id, Set.subset(atoms, atomSet));
+		isStrictSuperset.set(id, Set.subset(atomSet, atoms) && !Set.eq(atomSet, atoms));
+	}, this);
+	var parents = atomSets.findAll(function (id) {
+		if (!isSubset.get(id))
+			return false;
+		if (this.children.get(id).findIndex(function (childId) {
+			return isSubset.get(childId);
+		}, this) >= 0)
+			return false;
+		return true;
+	}, this);
+	console.assert(parents.length <= 1, "We are here"); // there should be only one parent
+
+	var children = atomSets.findAll(function (id) {
+		return isStrictSuperset.get(id) && !isStrictSuperset.get(this.parent.get(id));
+	}, this);
+	return {
+		children: children,
+		parent: parents.length === 0 ? -1 : parents[0]
+	};
+};
+
+SGroupForest.prototype.getPathToRoot = function (sgid) {
+	var path = [];
+	for (var id = sgid; id >= 0; id = this.parent.get(id)) {
+		console.assert(path.indexOf(id) < 0, 'SGroupForest: loop detected');
+		path.push(id);
+	}
+	return path;
+};
+
+SGroupForest.prototype.validate = function () {
+	var atomSets = this.getAtomSets();
+	this.molecule.sgroups.each(function (id) {
+		this.getPathToRoot(id); // this will throw an exception if there is a loop in the path to root
+	}, this);
+
+	var valid = true;
+	// 1) child group's atom set is a subset of the parent one's
+	this.parent.each(function (id, parentId) {
+		if (parentId >= 0 && !Set.subset(atomSets.get(id), atomSets.get(parentId)))
+			valid = false;
+	}, this);
+
+	// 2) siblings have disjoint atom sets
+	this.children.each(function (parentId) {
+		var list = this.children.get(parentId);
+		for (var i = 0; i < list.length; ++i) {
+			for (var j = i + 1; j < list.length; ++j) {
+				var id1 = list[i];
+				var id2 = list[j];
+				var sg1 = this.molecule.sgroups.get(id1);
+				var sg2 = this.molecule.sgroups.get(id2);
+				if (!Set.disjoint(atomSets.get(id1), atomSets.get(id2)) && sg1.type != 'DAT' && sg2.type != 'DAT')
+					valid = false;
+			}
+		}
+	}, this);
+	return valid;
+};
+
+SGroupForest.prototype.insert = function (id, parent /* int, optional */, children /* [int], optional */) {
+	console.assert(!this.parent.has(id), 'sgid already present in the forest');
+	console.assert(!this.children.has(id), 'sgid already present in the forest');
+	console.assert(this.validate(), 's-group forest invalid');
+
+	var atomSets = this.getAtomSets();
+	var atoms = Set.fromList(this.molecule.sgroups.get(id).atoms);
+	if (!parent || !children) { // if these are not provided, deduce automatically
+		var guess = this.getAtomSetRelations(id, atoms, atomSets);
+		parent = guess.parent;
+		children = guess.children;
+	}
+
+	// TODO: make children Map<int, Set> instead of Map<int, []>?
+	children.forEach(function (childId) { // reset parent links
+		var childs = this.children.get(this.parent.get(childId));
+		var i = childs.indexOf(childId);
+		console.assert(i >= 0 && childs.indexOf(childId, i + 1) < 0, 'Assertion failed'); // one element
+		childs.splice(i, 1);
+		this.parent.set(childId, id);
+	}, this);
+	this.children.set(id, children);
+	this.parent.set(id, parent);
+	this.children.get(parent).push(id);
+	console.assert(this.validate(), 's-group forest invalid');
+	return { parent: parent, children: children };
+};
+
+SGroupForest.prototype.remove = function (id) {
+	console.assert(this.parent.has(id), 'sgid is not in the forest');
+	console.assert(this.children.has(id), 'sgid is not in the forest');
+	console.assert(this.validate(), 's-group forest invalid');
+
+	var parentId = this.parent.get(id);
+	this.children.get(id).forEach(function (childId) { // reset parent links
+		this.parent.set(childId, parentId);
+		this.children.get(parentId).push(childId);
+	}, this);
+
+	var childs = this.children.get(parentId);
+	var i = childs.indexOf(id);
+	console.assert(i >= 0 && childs.indexOf(id, i + 1) < 0, 'Assertion failed'); // one element
+	childs.splice(i, 1);
+
+	this.children.unset(id);
+	this.parent.unset(id);
+	console.assert(this.validate(), 's-group forest invalid');
+};
+
+module.exports = SGroupForest;