3 * This source code is part of
7 * GROningen MAchine for Chemical Simulations
9 * Written by David van der Spoel, Erik Lindahl, Berk Hess, and others.
10 * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
11 * Copyright (c) 2001-2009, The GROMACS development team,
12 * check out http://www.gromacs.org for more information.
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version 2
17 * of the License, or (at your option) any later version.
19 * If you want to redistribute modifications, please consider that
20 * scientific software is very special. Version control is crucial -
21 * bugs must be traceable. We will be happy to consider code for
22 * inclusion in the official distribution, but derived work must not
23 * be called official GROMACS. Details are found in the README & COPYING
24 * files - if they are missing, get the official version at www.gromacs.org.
26 * To help us fund GROMACS development, we humbly ask that you cite
27 * the papers on the package - you can find them in the top README file.
29 * For more info, check our website at http://www.gromacs.org
33 * Implements functions in evaluate.h.
36 * One of the major bottlenecks for selection performance is that all the
37 * evaluation is carried out for atoms.
38 * There are several cases when the evaluation could be done for residues
39 * or molecules instead, including keywords that select by residue and
40 * cases where residue centers are used as reference positions.
41 * Implementing this would require a mechanism for recognizing whether
42 * something can be evaluated by residue/molecule instead by atom, and
43 * converting selections by residue/molecule into selections by atom
46 * \author Teemu Murtola <teemu.murtola@cbr.su.se>
47 * \ingroup module_selection
51 #include "gromacs/legacyheaders/maths.h"
52 #include "gromacs/legacyheaders/smalloc.h"
53 #include "gromacs/legacyheaders/vec.h"
55 #include "gromacs/selection/indexutil.h"
56 #include "gromacs/selection/poscalc.h"
57 #include "gromacs/selection/selection.h"
58 #include "gromacs/selection/selmethod.h"
59 #include "gromacs/utility/exceptions.h"
60 #include "gromacs/utility/gmxassert.h"
64 #include "selectioncollection-impl.h"
67 using gmx::SelectionTreeElement;
68 using gmx::SelectionTreeElementPointer;
74 * Reserves memory for a selection element from the evaluation memory pool.
76 * This class implements RAII semantics for allocating memory for selection
77 * element values from a selection evaluation memory pool.
79 * \ingroup module_selection
81 class MempoolSelelemReserver
84 //! Constructs a reserver without initial reservation.
85 MempoolSelelemReserver() {}
87 * Constructs a reserver with initial reservation.
89 * \param[in,out] sel Selection element for which to reserve.
90 * \param[in] count Number of values to reserve.
94 MempoolSelelemReserver(const SelectionTreeElementPointer &sel, int count)
98 //! Frees any memory allocated using this reserver.
99 ~MempoolSelelemReserver()
103 sel_->mempoolRelease();
108 * Reserves memory for selection element values using this reserver.
110 * \param[in,out] sel Selection element for which to reserve.
111 * \param[in] count Number of values to reserve.
113 * Allocates space to store \p count output values in \p sel from the
114 * memory pool associated with \p sel, or from the heap if there is no
115 * memory pool. Type of values to allocate is automatically determined
118 void reserve(const SelectionTreeElementPointer &sel, int count)
120 GMX_RELEASE_ASSERT(!sel_,
121 "Can only reserve one element with one instance");
122 sel->mempoolReserve(count);
127 SelectionTreeElementPointer sel_;
131 * Reserves memory for an index group from the evaluation memory pool.
133 * This class implements RAII semantics for allocating memory for an index
134 * group from a selection evaluation memory pool.
136 * \ingroup module_selection
138 class MempoolGroupReserver
142 * Creates a reserver associated with a given memory pool.
144 * \param mp Memory pool from which to reserve memory.
146 explicit MempoolGroupReserver(gmx_sel_mempool_t *mp)
150 //! Frees any memory allocated using this reserver.
151 ~MempoolGroupReserver()
155 _gmx_sel_mempool_free_group(mp_, g_);
160 * Reserves memory for an index group using this reserver.
162 * \param[in,out] g Index group to reserve.
163 * \param[in] count Number of atoms to reserve space for.
165 * Allocates memory from the memory pool to store \p count atoms in
168 void reserve(gmx_ana_index_t *g, int count)
170 GMX_RELEASE_ASSERT(g_ == NULL, "Can only reserve one element with one instance");
171 _gmx_sel_mempool_alloc_group(mp_, g, count);
176 gmx_sel_mempool_t *mp_;
181 * Assigns a temporary value for a selection element.
183 * This class implements RAII semantics for temporarily assigning the value
184 * pointer of a selection element to point to a different location.
186 * \ingroup module_selection
188 class SelelemTemporaryValueAssigner
191 //! Constructs an assigner without an initial assignment.
192 SelelemTemporaryValueAssigner()
193 : old_ptr_(NULL), old_nalloc_(0)
197 * Constructs an assigner with an initial assignment.
199 * \param[in,out] sel Selection element for which to assign.
200 * \param[in] vsource Element to which \p sel values will point to.
204 SelelemTemporaryValueAssigner(const SelectionTreeElementPointer &sel,
205 const SelectionTreeElement &vsource)
207 assign(sel, vsource);
209 //! Undoes any temporary assignment done using this assigner.
210 ~SelelemTemporaryValueAssigner()
214 _gmx_selvalue_setstore_alloc(&sel_->v, old_ptr_, old_nalloc_);
219 * Assigns a temporary value pointer.
221 * \param[in,out] sel Selection element for which to assign.
222 * \param[in] vsource Element to which \p sel values will point to.
224 * Assigns the value pointer in \p sel to point to the values in
225 * \p vsource, i.e., any access/modification to values in \p sel
226 * actually accesses values in \p vsource.
228 void assign(const SelectionTreeElementPointer &sel,
229 const SelectionTreeElement &vsource)
231 GMX_RELEASE_ASSERT(!sel_,
232 "Can only assign one element with one instance");
233 GMX_RELEASE_ASSERT(sel->v.type == vsource.v.type,
234 "Mismatching selection value types");
235 old_ptr_ = sel->v.u.ptr;
236 old_nalloc_ = sel->v.nalloc;
237 _gmx_selvalue_setstore(&sel->v, vsource.v.u.ptr);
242 SelectionTreeElementPointer sel_;
250 * \param[in] fp File handle to receive the output.
251 * \param[in] evalfunc Function pointer to print.
254 _gmx_sel_print_evalfunc_name(FILE *fp, gmx::sel_evalfunc evalfunc)
260 else if (evalfunc == &_gmx_sel_evaluate_root)
264 else if (evalfunc == &_gmx_sel_evaluate_static)
266 fprintf(fp, "static");
268 else if (evalfunc == &_gmx_sel_evaluate_subexpr_simple)
270 fprintf(fp, "subexpr_simple");
272 else if (evalfunc == &_gmx_sel_evaluate_subexpr_staticeval)
274 fprintf(fp, "subexpr_staticeval");
276 else if (evalfunc == &_gmx_sel_evaluate_subexpr)
278 fprintf(fp, "subexpr");
280 else if (evalfunc == &_gmx_sel_evaluate_subexprref_simple)
282 fprintf(fp, "ref_simple");
284 else if (evalfunc == &_gmx_sel_evaluate_subexprref)
288 else if (evalfunc == &_gmx_sel_evaluate_method)
290 fprintf(fp, "method");
292 else if (evalfunc == &_gmx_sel_evaluate_modifier)
296 else if (evalfunc == &_gmx_sel_evaluate_not)
300 else if (evalfunc == &_gmx_sel_evaluate_and)
304 else if (evalfunc == &_gmx_sel_evaluate_or)
308 else if (evalfunc == &_gmx_sel_evaluate_arithmetic)
310 fprintf(fp, "arithmetic");
314 fprintf(fp, "%p", (void*)(evalfunc));
319 * \param[out] data Evaluation data structure to initialize.
320 * \param[in] mp Memory pool for intermediate evaluation values.
321 * \param[in] gall Index group with all the atoms.
322 * \param[in] top Topology structure for evaluation.
323 * \param[in] fr New frame for evaluation.
324 * \param[in] pbc New PBC information for evaluation.
327 _gmx_sel_evaluate_init(gmx_sel_evaluate_t *data,
328 gmx_sel_mempool_t *mp, gmx_ana_index_t *gall,
329 t_topology *top, t_trxframe *fr, t_pbc *pbc)
339 * Recursively initializes the flags for evaluation.
341 * \param[in,out] sel Selection element to clear.
343 * The \ref SEL_INITFRAME flag is set for \ref SEL_EXPRESSION elements whose
344 * method defines the \p init_frame callback (see sel_framefunc()), and
345 * cleared for other elements.
347 * The \ref SEL_EVALFRAME flag is cleared for all elements.
350 init_frame_eval(SelectionTreeElementPointer sel)
354 sel->flags &= ~(SEL_INITFRAME | SEL_EVALFRAME);
355 if (sel->type == SEL_EXPRESSION)
357 if (sel->u.expr.method && sel->u.expr.method->init_frame)
359 sel->flags |= SEL_INITFRAME;
362 if (sel->child && sel->type != SEL_SUBEXPRREF)
364 init_frame_eval(sel->child);
373 SelectionEvaluator::SelectionEvaluator()
378 * \param[in,out] coll The selection collection to evaluate.
379 * \param[in] fr Frame for which the evaluation should be carried out.
380 * \param[in] pbc PBC data, or NULL if no PBC should be used.
381 * \returns 0 on successful evaluation, a non-zero error code on error.
383 * This functions sets the global variables for topology, frame and PBC,
384 * clears some information in the selection to initialize the evaluation
385 * for a new frame, and evaluates \p sel and all the selections pointed by
386 * the \p next pointers of \p sel.
388 * This is the only function that user code should call if they want to
389 * evaluate a selection for a new frame.
392 SelectionEvaluator::evaluate(SelectionCollection *coll,
393 t_trxframe *fr, t_pbc *pbc)
395 gmx_ana_selcollection_t *sc = &coll->impl_->sc_;
396 gmx_sel_evaluate_t data;
398 _gmx_sel_evaluate_init(&data, sc->mempool, &sc->gall, sc->top, fr, pbc);
399 init_frame_eval(sc->root);
400 SelectionTreeElementPointer sel = sc->root;
403 /* Clear the evaluation group of subexpressions */
404 if (sel->child && sel->child->type == SEL_SUBEXPR)
406 sel->child->u.cgrp.isize = 0;
407 /* Not strictly necessary, because the value will be overwritten
408 * during first evaluation of the subexpression anyways, but we
409 * clear the group for clarity. Note that this is _not_ done during
410 * compilation because of some additional complexities involved
411 * (see compiler.c), so it should not be relied upon in
412 * _gmx_sel_evaluate_subexpr(). */
413 if (sel->child->v.type == GROUP_VALUE)
415 sel->child->v.u.g->isize = 0;
420 sel->evaluate(&data, sel, NULL);
424 /* Update selection information */
425 SelectionDataList::const_iterator isel;
426 for (isel = sc->sel.begin(); isel != sc->sel.end(); ++isel)
428 internal::SelectionData &sel = **isel;
429 sel.refreshMassesAndCharges();
430 sel.updateCoveredFractionForFrame();
435 * \param[in,out] coll The selection collection to evaluate.
436 * \param[in] nframes Total number of frames.
439 SelectionEvaluator::evaluateFinal(SelectionCollection *coll, int nframes)
441 gmx_ana_selcollection_t *sc = &coll->impl_->sc_;
443 SelectionDataList::const_iterator isel;
444 for (isel = sc->sel.begin(); isel != sc->sel.end(); ++isel)
446 internal::SelectionData &sel = **isel;
447 sel.restoreOriginalPositions();
448 sel.computeAverageCoveredFraction(nframes);
455 * \param[in] data Data for the current frame.
456 * \param[in] sel Selection element being evaluated.
457 * \param[in] g Group for which \p sel should be evaluated.
458 * \returns 0 on success, a non-zero error code on error.
460 * Evaluates each child of \p sel in \p g.
463 _gmx_sel_evaluate_children(gmx_sel_evaluate_t *data,
464 const SelectionTreeElementPointer &sel,
467 SelectionTreeElementPointer child = sel->child;
472 child->evaluate(data, child, g);
479 * \param[in] data Data for the current frame.
480 * \param[in] sel Selection element being evaluated.
481 * \param[in] g Group for which \p sel should be evaluated
482 * (not used, can be NULL).
483 * \returns 0 on success, a non-zero error code on error.
485 * Evaluates the first child element in the group defined by \p sel->u.cgrp.
486 * If \p sel->u.cgrp is empty, nothing is done.
487 * The value of \p sel is not touched (root elements do not evaluate to
490 * This function can be used as gmx::SelectionTreeElement::evaluate for
491 * \ref SEL_ROOT elements.
494 _gmx_sel_evaluate_root(gmx_sel_evaluate_t *data,
495 const SelectionTreeElementPointer &sel,
498 if (sel->u.cgrp.isize == 0 || !sel->child->evaluate)
503 sel->child->evaluate(data, sel->child,
504 sel->u.cgrp.isize < 0 ? NULL : &sel->u.cgrp);
508 * \param[in] data Data for the current frame.
509 * \param[in] sel Selection element being evaluated.
510 * \param[in] g Group for which \p sel should be evaluated.
511 * \returns 0 for success.
513 * Sets the value of \p sel to the intersection of \p g and \p sel->u.cgrp.
515 * This function can be used as gmx::SelectionTreeElement::evaluate for
516 * \ref SEL_CONST elements with value type \ref GROUP_VALUE.
519 _gmx_sel_evaluate_static(gmx_sel_evaluate_t *data,
520 const SelectionTreeElementPointer &sel,
523 gmx_ana_index_intersection(sel->v.u.g, &sel->u.cgrp, g);
527 /*********************************************************************
528 * SUBEXPRESSION EVALUATION
529 *********************************************************************/
532 * \param[in] data Data for the current frame.
533 * \param[in] sel Selection element being evaluated.
534 * \param[in] g Group for which \p sel should be evaluated.
535 * \returns 0 on success, a non-zero error code on error.
537 * Evaluates the child element (there should be exactly one) in \p g.
538 * The compiler has taken care that the child actually stores the evaluated
539 * value in the value pointer of this element.
541 * This function is used as gmx::SelectionTreeElement::evaluate for
542 * \ref SEL_SUBEXPR elements that are used only once, and hence do not need
543 * full subexpression handling.
546 _gmx_sel_evaluate_subexpr_simple(gmx_sel_evaluate_t *data,
547 const SelectionTreeElementPointer &sel,
550 if (sel->child->evaluate)
552 sel->child->evaluate(data, sel->child, g);
554 sel->v.nr = sel->child->v.nr;
558 * \param[in] data Data for the current frame.
559 * \param[in] sel Selection element being evaluated.
560 * \param[in] g Group for which \p sel should be evaluated.
561 * \returns 0 on success, a non-zero error code on error.
563 * If this is the first call for this frame, evaluates the child element
564 * there should be exactly one in \p g.
565 * The compiler has taken care that the child actually stores the evaluated
566 * value in the value pointer of this element.
567 * Assumes that \p g is persistent for the duration of the whole evaluation.
569 * This function is used as gmx::SelectionTreeElement::evaluate for
570 * \ref SEL_SUBEXPR elements that have a static evaluation group, and hence do
571 * not need full subexpression handling.
574 _gmx_sel_evaluate_subexpr_staticeval(gmx_sel_evaluate_t *data,
575 const SelectionTreeElementPointer &sel,
578 if (sel->u.cgrp.isize == 0)
580 sel->child->evaluate(data, sel->child, g);
581 sel->v.nr = sel->child->v.nr;
584 sel->u.cgrp.isize = -1;
588 gmx_ana_index_set(&sel->u.cgrp, g->isize, g->index, sel->u.cgrp.name, 0);
594 * \param[in] data Data for the current frame.
595 * \param[in] sel Selection element being evaluated.
596 * \param[in] g Group for which \p sel should be evaluated.
597 * \returns 0 on success, a non-zero error code on error.
599 * Finds the part of \p g for which the subexpression
600 * has not yet been evaluated by comparing \p g to \p sel->u.cgrp.
601 * If the part is not empty, the child expression is evaluated for this
602 * part, and the results merged to the old values of the child.
603 * The value of \p sel itself is undefined after the call.
606 * The call to gmx_ana_index_difference() can take quite a lot of unnecessary
607 * time if the subexpression is evaluated either several times for the same
608 * group or for completely distinct groups.
609 * However, in the majority of cases, these situations occur when
610 * _gmx_sel_evaluate_subexpr_staticeval() can be used, so this should not be a
614 _gmx_sel_evaluate_subexpr(gmx_sel_evaluate_t *data,
615 const SelectionTreeElementPointer &sel,
618 gmx_ana_index_t gmiss;
620 MempoolGroupReserver gmissreserver(data->mp);
621 if (sel->u.cgrp.isize == 0)
624 SelelemTemporaryValueAssigner assigner(sel->child, *sel);
625 sel->child->evaluate(data, sel->child, g);
627 /* We need to keep the name for the cgrp across the copy to avoid
628 * problems if g has a name set. */
629 char *name = sel->u.cgrp.name;
630 gmx_ana_index_copy(&sel->u.cgrp, g, false);
631 sel->u.cgrp.name = name;
636 gmissreserver.reserve(&gmiss, g->isize);
637 gmx_ana_index_difference(&gmiss, g, &sel->u.cgrp);
642 MempoolSelelemReserver reserver(sel->child, gmiss.isize);
643 /* Evaluate the missing values for the child */
644 sel->child->evaluate(data, sel->child, &gmiss);
645 /* Merge the missing values to the existing ones. */
646 if (sel->v.type == GROUP_VALUE)
648 gmx_ana_index_merge(sel->v.u.g, sel->child->v.u.g, sel->v.u.g);
654 i = sel->u.cgrp.isize - 1;
656 /* TODO: This switch is kind of ugly, but it may be difficult to
657 * do this portably without C++ templates. */
661 for (k = sel->u.cgrp.isize + gmiss.isize - 1; k >= 0; k--)
663 if (i < 0 || (j >= 0 && sel->u.cgrp.index[i] < gmiss.index[j]))
665 sel->v.u.i[k] = sel->child->v.u.i[j--];
669 sel->v.u.i[k] = sel->v.u.i[i--];
675 for (k = sel->u.cgrp.isize + gmiss.isize - 1; k >= 0; k--)
677 if (i < 0 || (j >= 0 && sel->u.cgrp.index[i] < gmiss.index[j]))
679 sel->v.u.r[k] = sel->child->v.u.r[j--];
683 sel->v.u.r[k] = sel->v.u.r[i--];
689 // Note: with the currently allowed syntax, this case is never
691 for (k = sel->u.cgrp.isize + gmiss.isize - 1; k >= 0; k--)
693 if (i < 0 || (j >= 0 && sel->u.cgrp.index[i] < gmiss.index[j]))
695 sel->v.u.s[k] = sel->child->v.u.s[j--];
699 sel->v.u.s[k] = sel->v.u.s[i--];
705 /* TODO: Implement this */
706 GMX_THROW(gmx::NotImplementedError("position subexpressions not implemented properly"));
710 GMX_THROW(gmx::InternalError("Invalid subexpression type"));
713 gmx_ana_index_merge(&sel->u.cgrp, &sel->u.cgrp, &gmiss);
718 * \param[in] data Data for the current frame.
719 * \param[in] sel Selection element being evaluated.
720 * \param[in] g Group for which \p sel should be evaluated.
721 * \returns 0 for success.
723 * Sets the value pointers of the child and its child to point to the same
724 * memory as the value pointer of this element to avoid copying, and then
725 * evaluates evaluates the child.
727 * This function is used as gmx::SelectionTreeElement:evaluate for
728 * \ref SEL_SUBEXPRREF elements for which the \ref SEL_SUBEXPR does not have
732 _gmx_sel_evaluate_subexprref_simple(gmx_sel_evaluate_t *data,
733 const SelectionTreeElementPointer &sel,
738 _gmx_selvalue_setstore(&sel->child->v, sel->v.u.ptr);
739 _gmx_selvalue_setstore_alloc(&sel->child->child->v, sel->v.u.ptr,
740 sel->child->child->v.nalloc);
741 sel->child->evaluate(data, sel->child, g);
743 sel->v.nr = sel->child->v.nr;
746 sel->u.param->val.nr = sel->v.nr;
747 if (sel->u.param->nvalptr)
749 *sel->u.param->nvalptr = sel->u.param->val.nr;
755 * \param[in] data Data for the current frame.
756 * \param[in] sel Selection element being evaluated.
757 * \param[in] g Group for which \p sel should be evaluated.
758 * \returns 0 on success, a non-zero error code on error.
760 * If the value type is \ref POS_VALUE, the value of the child is simply
761 * copied to set the value of \p sel (the child subexpression should
762 * already have been evaluated by its root).
763 * If the value type is something else, the child is evaluated for the
764 * group \p g, and the value of the child is then copied.
765 * There should be only one child element.
767 * This function is used as gmx::SelectionTreeElement::evaluate for
768 * \ref SEL_SUBEXPRREF elements.
771 _gmx_sel_evaluate_subexprref(gmx_sel_evaluate_t *data,
772 const SelectionTreeElementPointer &sel,
779 sel->child->evaluate(data, sel->child, g);
781 const SelectionTreeElementPointer &expr = sel->child;
787 sel->v.nr = expr->v.nr;
788 memcpy(sel->v.u.i, expr->v.u.i, sel->v.nr*sizeof(*sel->v.u.i));
792 sel->v.nr = g->isize;
793 /* Extract the values corresponding to g */
794 for (i = j = 0; i < g->isize; ++i, ++j)
796 while (sel->child->u.cgrp.index[j] < g->index[i])
800 sel->v.u.i[i] = expr->v.u.i[j];
808 sel->v.nr = expr->v.nr;
809 memcpy(sel->v.u.r, expr->v.u.r, sel->v.nr*sizeof(*sel->v.u.r));
813 sel->v.nr = g->isize;
814 /* Extract the values corresponding to g */
815 for (i = j = 0; i < g->isize; ++i, ++j)
817 while (sel->child->u.cgrp.index[j] < g->index[i])
821 sel->v.u.r[i] = expr->v.u.r[j];
829 sel->v.nr = expr->v.nr;
830 memcpy(sel->v.u.s, expr->v.u.s, sel->v.nr*sizeof(*sel->v.u.s));
834 sel->v.nr = g->isize;
835 /* Extract the values corresponding to g */
836 for (i = j = 0; i < g->isize; ++i, ++j)
838 while (sel->child->u.cgrp.index[j] < g->index[i])
842 sel->v.u.s[i] = expr->v.u.s[j];
848 /* Currently, there is no need to do anything fancy here,
849 * but some future extensions may need a more flexible
851 gmx_ana_pos_copy(sel->v.u.p, expr->v.u.p, false);
857 gmx_ana_index_copy(sel->v.u.g, expr->v.u.g, false);
861 gmx_ana_index_intersection(sel->v.u.g, expr->v.u.g, g);
865 default: /* should not be reached */
866 GMX_THROW(gmx::InternalError("Invalid subexpression reference type"));
868 /* Store the number of values if needed */
871 sel->u.param->val.nr = sel->v.nr;
872 if (sel->u.param->nvalptr)
874 *sel->u.param->nvalptr = sel->u.param->val.nr;
879 /********************************************************************
880 * METHOD EXPRESSION EVALUATION
881 ********************************************************************/
884 * \param[in] data Data for the current frame.
885 * \param[in] sel Selection element being evaluated.
886 * \param[in] g Group for which \p sel should be evaluated.
887 * \returns 0 on success, a non-zero error code on error.
889 * Evaluates each child of a \ref SEL_EXPRESSION element.
890 * The value of \p sel is not touched.
892 * This function is not used as gmx::SelectionTreeElement::evaluate,
893 * but is used internally.
896 _gmx_sel_evaluate_method_params(gmx_sel_evaluate_t *data,
897 const SelectionTreeElementPointer &sel,
900 SelectionTreeElementPointer child = sel->child;
903 if (child->evaluate && !(child->flags & SEL_EVALFRAME))
905 if (child->flags & SEL_ATOMVAL)
907 child->evaluate(data, child, g);
911 child->flags |= SEL_EVALFRAME;
912 child->evaluate(data, child, NULL);
920 * \param[in] data Data for the current frame.
921 * \param[in] sel Selection element being evaluated.
922 * \param[in] g Group for which \p sel should be evaluated.
923 * \returns 0 on success, a non-zero error code on error.
925 * Evaluates all child selections (using _gmx_sel_evaluate_method_params())
926 * to evaluate any parameter values.
927 * If this is the first time this expression is evaluated for
928 * the frame, sel_framefunc() callback is called if one is provided.
929 * If a reference position calculation has been initialized for this element,
930 * the positions are also updated, and sel_updatefunc_pos() is used to
931 * evaluate the value. Otherwise, sel_updatefunc() is used.
933 * This function is used as gmx::SelectionTreeElement::evaluate for
934 * \ref SEL_EXPRESSION elements.
937 _gmx_sel_evaluate_method(gmx_sel_evaluate_t *data,
938 const SelectionTreeElementPointer &sel,
941 _gmx_sel_evaluate_method_params(data, sel, g);
942 if (sel->flags & SEL_INITFRAME)
944 sel->flags &= ~SEL_INITFRAME;
945 sel->u.expr.method->init_frame(data->top, data->fr, data->pbc,
950 gmx_ana_poscalc_update(sel->u.expr.pc, sel->u.expr.pos, g,
951 data->fr, data->pbc);
952 sel->u.expr.method->pupdate(data->top, data->fr, data->pbc,
953 sel->u.expr.pos, &sel->v,
958 sel->u.expr.method->update(data->top, data->fr, data->pbc, g,
959 &sel->v, sel->u.expr.mdata);
964 * \param[in] data Data for the current frame.
965 * \param[in] sel Selection element being evaluated.
966 * \param[in] g Group for which \p sel should be evaluated.
967 * \returns 0 on success, a non-zero error code on error.
969 * Evaluates all child selections (using _gmx_sel_evaluate_method_params())
970 * to evaluate any parameter values.
971 * If this is the first time this expression is evaluated for
972 * the frame, sel_framefunc() callback is called if one is provided.
973 * The modifier is then evaluated using sel_updatefunc_pos().
975 * This function is used as gmx::SelectionTreeElement::evaluate for
976 * \ref SEL_MODIFIER elements.
979 _gmx_sel_evaluate_modifier(gmx_sel_evaluate_t *data,
980 const SelectionTreeElementPointer &sel,
983 _gmx_sel_evaluate_method_params(data, sel, g);
984 if (sel->flags & SEL_INITFRAME)
986 sel->flags &= ~SEL_INITFRAME;
987 sel->u.expr.method->init_frame(data->top, data->fr, data->pbc,
990 GMX_RELEASE_ASSERT(sel->child != NULL,
991 "Modifier element with a value must have a child");
992 if (sel->child->v.type != POS_VALUE)
994 GMX_THROW(gmx::NotImplementedError("Non-position valued modifiers not implemented"));
996 sel->u.expr.method->pupdate(data->top, data->fr, data->pbc,
998 &sel->v, sel->u.expr.mdata);
1002 /********************************************************************
1003 * BOOLEAN EXPRESSION EVALUATION
1004 ********************************************************************/
1007 * \param[in] data Data for the current frame.
1008 * \param[in] sel Selection element being evaluated.
1009 * \param[in] g Group for which \p sel should be evaluated.
1010 * \returns 0 on success, a non-zero error code on error.
1012 * Evaluates the child element (there should be only one) in the group
1013 * \p g, and then sets the value of \p sel to the complement of the
1016 * This function is used as gmx::SelectionTreeElement::evaluate for
1017 * \ref SEL_BOOLEAN elements with \ref BOOL_NOT.
1020 _gmx_sel_evaluate_not(gmx_sel_evaluate_t *data,
1021 const SelectionTreeElementPointer &sel,
1024 MempoolSelelemReserver reserver(sel->child, g->isize);
1025 sel->child->evaluate(data, sel->child, g);
1026 gmx_ana_index_difference(sel->v.u.g, g, sel->child->v.u.g);
1030 * \param[in] data Data for the current frame.
1031 * \param[in] sel Selection element being evaluated.
1032 * \param[in] g Group for which \p sel should be evaluated.
1033 * \returns 0 on success, a non-zero error code on error.
1035 * Short-circuiting evaluation of logical AND expressions.
1037 * Starts by evaluating the first child element in the group \p g.
1038 * The each following child element is evaluated in the intersection
1039 * of all the previous values until all children have been evaluated
1040 * or the intersection becomes empty.
1041 * The value of \p sel is set to the intersection of all the (evaluated)
1044 * If the first child does not have an evaluation function, it is skipped
1045 * and the evaluation is started at the second child.
1046 * This happens if the first child is a constant expression and during
1047 * compilation it was detected that the evaluation group is always a subset
1048 * of the constant group
1049 * (currently, the compiler never detects this).
1051 * This function is used as gmx::SelectionTreeElement::evaluate for
1052 * \ref SEL_BOOLEAN elements with \ref BOOL_AND.
1055 _gmx_sel_evaluate_and(gmx_sel_evaluate_t *data,
1056 const SelectionTreeElementPointer &sel,
1059 SelectionTreeElementPointer child = sel->child;
1060 /* Skip the first child if it does not have an evaluation function. */
1061 if (!child->evaluate)
1063 child = child->next;
1065 /* Evaluate the first child */
1067 MempoolSelelemReserver reserver(child, g->isize);
1068 child->evaluate(data, child, g);
1069 gmx_ana_index_copy(sel->v.u.g, child->v.u.g, false);
1071 child = child->next;
1072 while (child && sel->v.u.g->isize > 0)
1074 MempoolSelelemReserver reserver(child, sel->v.u.g->isize);
1075 child->evaluate(data, child, sel->v.u.g);
1076 gmx_ana_index_intersection(sel->v.u.g, sel->v.u.g, child->v.u.g);
1077 child = child->next;
1082 * \param[in] data Data for the current frame.
1083 * \param[in] sel Selection element being evaluated.
1084 * \param[in] g Group for which \p sel should be evaluated.
1085 * \returns 0 on success, a non-zero error code on error.
1087 * Short-circuiting evaluation of logical OR expressions.
1089 * Starts by evaluating the first child element in the group \p g.
1090 * For each subsequent child, finds the part of \p g that is not
1091 * included the value of any previous child, and evaluates the child
1092 * in that group until the last child is evaluated or all of \p g
1093 * is included in some child value.
1094 * The value of \p sel is set to the union of all the (evaluated)
1097 * If the first child does not have an evaluation function, its value is
1098 * used without evaluation.
1099 * This happens if the first child is a constant expression, the selection
1100 * has been compiled, and the evaluation group is the same for each frame.
1101 * In this case, the compiler has taken care of that the child value is a
1102 * subset of \p g, making it unnecessary to evaluate it.
1104 * This function is used as gmx::SelectionTreeElement::evaluate for
1105 * \ref SEL_BOOLEAN elements with \ref BOOL_OR.
1108 _gmx_sel_evaluate_or(gmx_sel_evaluate_t *data,
1109 const SelectionTreeElementPointer &sel,
1112 gmx_ana_index_t tmp, tmp2;
1114 SelectionTreeElementPointer child = sel->child;
1115 if (child->evaluate)
1117 MempoolSelelemReserver reserver(child, g->isize);
1118 child->evaluate(data, child, g);
1119 gmx_ana_index_partition(sel->v.u.g, &tmp, g, child->v.u.g);
1123 gmx_ana_index_partition(sel->v.u.g, &tmp, g, child->v.u.g);
1125 child = child->next;
1126 while (child && tmp.isize > 0)
1130 MempoolSelelemReserver reserver(child, tmp.isize);
1131 child->evaluate(data, child, &tmp);
1132 gmx_ana_index_partition(&tmp, &tmp2, &tmp, child->v.u.g);
1134 sel->v.u.g->isize += tmp.isize;
1135 tmp.isize = tmp2.isize;
1136 tmp.index = tmp2.index;
1137 child = child->next;
1139 gmx_ana_index_sort(sel->v.u.g);
1143 /********************************************************************
1144 * ARITHMETIC EVALUATION
1145 ********************************************************************/
1148 * \param[in] data Data for the current frame.
1149 * \param[in] sel Selection element being evaluated.
1150 * \param[in] g Group for which \p sel should be evaluated.
1151 * \returns 0 on success, a non-zero error code on error.
1154 _gmx_sel_evaluate_arithmetic(gmx_sel_evaluate_t *data,
1155 const SelectionTreeElementPointer &sel,
1159 real lval, rval = 0., val = 0.;
1161 const SelectionTreeElementPointer &left = sel->child;
1162 const SelectionTreeElementPointer &right = left->next;
1164 SelelemTemporaryValueAssigner assigner;
1165 MempoolSelelemReserver reserver;
1168 assigner.assign(left, *sel);
1171 reserver.reserve(right, g->isize);
1174 else if (right && right->mempool)
1176 assigner.assign(right, *sel);
1178 _gmx_sel_evaluate_children(data, sel, g);
1180 n = (sel->flags & SEL_SINGLEVAL) ? 1 : g->isize;
1183 bool bArithNeg = (sel->u.arith.type == ARITH_NEG);
1184 GMX_ASSERT(right || bArithNeg,
1185 "Right operand cannot be null except for negations");
1186 for (i = i1 = i2 = 0; i < n; ++i)
1188 lval = left->v.u.r[i1];
1191 rval = right->v.u.r[i2];
1193 switch (sel->u.arith.type)
1195 case ARITH_PLUS: val = lval + rval; break;
1196 case ARITH_MINUS: val = lval - rval; break;
1197 case ARITH_NEG: val = -lval; break;
1198 case ARITH_MULT: val = lval * rval; break;
1199 case ARITH_DIV: val = lval / rval; break;
1200 case ARITH_EXP: val = pow(lval, rval); break;
1202 sel->v.u.r[i] = val;
1203 if (!(left->flags & SEL_SINGLEVAL))
1207 if (!bArithNeg && !(right->flags & SEL_SINGLEVAL))