Implemented subset of atomSet: atomCount, queryCount and propertySet, which enables some of PyMOL operators. Implementation should be reviewed as byring is not working, and inorganic working incorrectly

src/mol-model/structure/query.ts

@@ -12,6 +12,7 @@ import * as modifiers from './query/queries/modifiers';
 import * as filters from './query/queries/filters';
 import * as combinators from './query/queries/combinators';
 import * as internal from './query/queries/internal';
+import * as atomset from './query/queries/atom-set';
 import { Predicates as pred } from './query/predicates';
 
 export const Queries = {
@@ -20,7 +21,8 @@ export const Queries = {
     modifiers,
     combinators,
     pred,
-    internal
+    internal,
+    atomset
 };
 
-export { StructureSelection, StructureQuery };
+export { StructureSelection, StructureQuery };

src/mol-model/structure/query/queries/atom-set.ts

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2017 MolQL contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+/*
+import Environment from '../environment'
+import Expression from '../expression'
+import Context from '../context'
+import AtomSet from '../../data/atom-set'
+import AtomSelection from '../../data/atom-selection'
+import ElementAddress from '../../data/element-address'
+import { FastSet } from '../../../utils/collections'
+import { getAtomSetProperties } from './filters'
+*/
+
+import { StructureQuery } from '../query';
+import { StructureSelection } from '../selection';
+import { getCurrentStructureProperties, UnitTypeProperties } from './filters';
+import { QueryContext } from '../context';
+//import { none } from './generators';
+//import { HashSet } from '../../../../mol-data/generic';
+//import { Structure } from '../../structure';
+
+
+/*
+import { SetUtils } from '../../../../mol-util/set';
+import { Unit } from '../../structure';
+import { QueryContext, QueryFn, QueryPredicate } from '../context';
+import { StructureQuery } from '../query';
+import { StructureSelection } from '../selection';
+import { structureAreIntersecting } from '../utils/structure-set';
+import { Vec3 } from '../../../../mol-math/linear-algebra';
+import { checkStructureMaxRadiusDistance, checkStructureMinMaxDistance } from '../utils/structure-distance';
+import { Structure } from '../../structure/structure';
+import { StructureElement } from '../../structure/element';
+import { SortedArray } from '../../../../mol-data/int';
+*/
+/*
+export function pick(query: StructureQuery, pred: QueryPredicate): StructureQuery {
+    return ctx => {
+        const sel = query(ctx);
+        const ret = StructureSelection.LinearBuilder(ctx.inputStructure);
+        ctx.pushCurrentElement();
+        StructureSelection.forEach(sel, (s, i) => {
+            ctx.currentStructure = s;
+            if (pred(ctx)) ret.add(s);
+            if (i % 100) ctx.throwIfTimedOut();
+        });
+        ctx.popCurrentStructure();
+        return ret.getSelection();
+    };
+}
+
+export function pick(env: Environment, selection: Selection, pred: Expression<boolean>) {
+    const sel = selection(env);
+    const ret = AtomSelection.linearBuilder();
+
+    Environment.lockSlot(env, 'atomSet');
+    const { slots } = env;
+    for (const atomSet of AtomSelection.atomSets(sel)) {
+        slots.atomSet = atomSet;
+        if (pred(env)) ret.add(atomSet);
+    }
+    Environment.unlockSlot(env, 'atomSet');
+    return ret.getSelection();
+}
+
+*/
+
+
+
+
+//xport function merge(queries: ArrayLike<StructureQuery>): S
+
+//export function atomCount(env: Environment) {
+//    return AtomSet.count(env.slots.atomSet);
+//}
+
+//export function atomCount(query : StructureSelection) : StructureQuery {
+export function atomCount(ctx:QueryContext) {
+    return (ctx:any) => {
+	const x : number  = StructureSelection.structureCount(ctx);
+        return x
+    };
+}
+
+//export function countQuery(env: Environment, query: Expression<AtomSelection>) {
+//    const sel = query(Environment(Context.ofAtomSet(env.context, env.slots.atomSet)))
+//    return AtomSelection.atomSets(sel).length;
+//}
+
+export function countQuery(ctx:QueryContext,query: StructureQuery){
+    return (ctx:any) => {
+        const sel = query(ctx);
+	const x : number  = StructureSelection.structureCount(sel);
+        return x
+    };
+}
+
+
+export function propertySet(ctx:QueryContext, prop: UnitTypeProperties) {
+    const set = new Set();
+    const x = getCurrentStructureProperties(ctx, prop, set)
+    return x
+}
+
+/*
+unction getSelectionProperties(ctx: QueryContext, query: StructureQuery, props: UnitTypeProperties) {
+
+  
+
+    const sel = query(ctx);
+    ctx.pushCurrentElement();
+    StructureSelection.forEach(sel, (s, i) => {
+	ctx.currentStructure = s;
+        getCurrentStructureProperties(ctx, props, set);
+
+        if (i % 10) ctx.throwIfTimedOut();
+    });
+    ctx.popCurrentElement();
+    return set;
+*/

src/mol-script/runtime/query/table.ts

@@ -357,6 +357,34 @@ const symbols = [
     D(MolScript.structureQuery.atomProperty.macromolecular.secondaryStructureFlags, atomProp(StructureProperties.residue.secondary_structure_type)),
     D(MolScript.structureQuery.atomProperty.macromolecular.chemCompType, atomProp(StructureProperties.residue.chem_comp_type)),
 
+    // ============= ATOM SET ================
+
+//    D(MolScript.structureQuery.combinator.merge, (ctx, xs) => Queries.combinators.merge(xs as any)(ctx)),
+    D(MolScript.structureQuery.atomSet.atomCount,     
+      function structureQuery_atomset_atomCount(ctx, xs) {
+	  console.log("From atomCount");
+	  console.log(Queries.atomset.atomCount(ctx))
+	  return Queries.atomset.atomCount(ctx)
+      }),
+
+
+    D(MolScript.structureQuery.atomSet.countQuery,     
+      function structureQuery_atomset_countQuery(ctx, xs) {
+	  console.log("From countQuery");
+	  console.log(Queries.atomset.countQuery(ctx,xs[0](ctx) as any))
+	  return Queries.atomset.countQuery(ctx,xs[0](ctx) as any)
+      }),
+
+//    env, v[0](env)
+
+    D(MolScript.structureQuery.atomSet.propertySet,     
+      function structureQuery_atomset_propertySet(ctx, xs) { return Queries.atomset.propertySet(ctx, xs[0] as any)}),
+//    D(MolScript.structureQuery.filter.withSameAtomProperties, (ctx, xs) => Queries.filters.withSameAtomProperties(xs[0] as any, xs['source'] as any, xs['property'] as any)(ctx)),
+    
+
+//    Symbol(MolQL.structure.atomSet.propertySet)((env, v) => StructureRuntime.AtomSet.propertySet(env, v[0])),
+
+    
     // ============= BOND PROPERTIES ================
     D(MolScript.structureQuery.bondProperty.order, (ctx, xs) => ctx.atomicBond.order),
     D(MolScript.structureQuery.bondProperty.flags, (ctx, xs) => ctx.atomicBond.type),

src/mol-script/transpilers/pymol/operators.ts

@@ -297,12 +297,12 @@ export const operators: OperatorList = [
         '@desc': 'All rings of size ≤ 7 which have at least one atom in s1.',
         '@examples': ['BYRING resn HEM'],
         name: 'byring',
-	isUnsupported: true, // structure-query.atom-set.atom-count' is not implemented.
+	//isUnsupported: true, // structure-query.atom-set.atom-count' is not implemented.
         type: h.prefix,
         rule: h.prefixOp(/BYRING/i),
         map: (op: string, selection: Expression) => {
             return h.asAtoms(
-                B.struct.filter.intersectedBy({
+		B.struct.modifier.intersectBy({
                     '0': B.struct.filter.pick({
                         '0': B.struct.generator.rings(),
                         test: B.core.logic.and([