void
-AbstractPlotModule::dataStarted(AbstractAnalysisData * /*data*/)
+AbstractPlotModule::dataStarted(AbstractAnalysisData * /* data */)
{
if (!impl_->filename_.empty())
{
for (f = 0; (f < tfn[i].nfiles); f++)
{
sprintf(buf, "%4s %14s %-12s ", (f == 0) ? tfn[i].opt : "",
- tfn[i].fns[f], (f == 0) ? fileopt(tfn[i].flag, opt_buf, 32)
+ tfn[i].fns[f], (f == 0) ? fileopt(tfn[i].flag, opt_buf)
: "");
if (f < tfn[i].nfiles - 1)
{
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
}
const HelpTopicInterface *
-AbstractSimpleHelpTopic::findSubTopic(const char *name) const
+AbstractSimpleHelpTopic::findSubTopic(const char * /* name */) const
{
return NULL;
}
}
#define FLAG_SET(flag, mask) ((flag &mask) == mask)
-char *fileopt(unsigned long flag, char buf[], int maxsize)
+char *fileopt(unsigned long flag, char buf[])
{
char tmp[256];
fprintf(out, ".BI \"%s\" \" %s\" \n.B %s\n %s \n\n",
check(fnm[i].opt, context).c_str(),
check(fnm[i].fns[0], context).c_str(),
- check(fileopt(fnm[i].flag, tmp, 255), context).c_str(),
+ check(fileopt(fnm[i].flag, tmp), context).c_str(),
check(ftp2desc(fnm[i].ftp), context).c_str());
}
}
"<TD> %s </TD>"
"<TD> %s </TD>"
"</TR>\n",
- fnm[i].opt, link, fnm[i].fns[0], fileopt(fnm[i].flag, tmp, 255),
+ fnm[i].opt, link, fnm[i].fns[0], fileopt(fnm[i].flag, tmp),
check(ftp2desc(fnm[i].ftp), context).c_str());
}
-
fprintf(out, "</TABLE>\n");
}
int npargs, t_pargs *pa,
int nbug, const char **bugs);
-char *fileopt(unsigned long flag, char buf[], int maxsize);
+char *fileopt(unsigned long flag, char buf[]);
/* Return a string describing the file type in flag.
* flag should the flag field of a filenm struct.
* You have to provide a buffer and buffer length in which
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2010,2011,2012, by the GROMACS development team, led by
+ * Copyright (c) 2010,2011,2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
#include <boost/scoped_ptr.hpp>
+#include "../utility/common.h"
#include "../utility/exceptions.h"
#include "../utility/gmxassert.h"
*/
virtual void processSetValues(ValueList *values)
{
+ GMX_UNUSED_VALUE(values);
}
/*! \copydoc gmx::AbstractOptionStorage::processSet()
*
#include "gromacs/legacyheaders/pbc.h"
#include "gromacs/legacyheaders/vec.h"
-/*!
- * \param[in] top Topology structure (unused, can be NULL).
- * \param[in] x Position vectors of all atoms.
- * \param[in] nrefat Number of atoms in the index.
- * \param[in] index Indices of atoms.
- * \param[out] xout COG position for the indexed atoms.
- * \returns 0 on success.
- */
int
-gmx_calc_cog(t_topology *top, rvec x[], int nrefat, atom_id index[], rvec xout)
+gmx_calc_cog(t_topology * /* top */, rvec x[], int nrefat, atom_id index[], rvec xout)
{
int m, ai;
return 0;
}
-/*!
- * \param[in] top Topology structure (unused, can be NULL).
- * \param[in] f Forces on all atoms.
- * \param[in] nrefat Number of atoms in the index.
- * \param[in] index Indices of atoms.
- * \param[out] fout Force on the COM position for the indexed atoms.
- * \returns 0 on success.
- */
int
-gmx_calc_com_f(t_topology *top, rvec f[], int nrefat, atom_id index[], rvec fout)
+gmx_calc_com_f(t_topology * /* top */, rvec f[], int nrefat, atom_id index[], rvec fout)
{
clear_rvec(fout);
for (int m = 0; m < nrefat; ++m)
}
-/*!
- * \param[in] top Topology structure (unused, can be NULL).
- * \param[in] x Position vectors of all atoms.
- * \param[in] block t_block structure that divides \p index into blocks.
- * \param[in] index Indices of atoms.
- * \param[out] xout \p block->nr COG positions.
- * \returns 0 on success.
- */
int
-gmx_calc_cog_block(t_topology *top, rvec x[], t_block *block, atom_id index[],
+gmx_calc_cog_block(t_topology * /* top */, rvec x[], t_block *block, atom_id index[],
rvec xout[])
{
int b, i, ai;
return 0;
}
-/*!
- * \param[in] top Topology structure (unused, can be NULL).
- * \param[in] f Forces on all atoms.
- * \param[in] block t_block structure that divides \p index into blocks.
- * \param[in] index Indices of atoms.
- * \param[out] fout \p block->nr Forces on COM positions.
- * \returns 0 on success.
- */
int
-gmx_calc_com_f_block(t_topology *top, rvec f[], t_block *block, atom_id index[],
+gmx_calc_com_f_block(t_topology * /* top */, rvec f[], t_block *block, atom_id index[],
rvec fout[])
{
for (int b = 0; b < block->nr; ++b)
#include "../legacyheaders/typedefs.h"
-/** Calculate a single center of geometry. */
+/*! \brief
+ * Calculate a single center of geometry.
+ *
+ * \param[in] top Topology structure (unused, can be NULL).
+ * \param[in] x Position vectors of all atoms.
+ * \param[in] nrefat Number of atoms in the index.
+ * \param[in] index Indices of atoms.
+ * \param[out] xout COG position for the indexed atoms.
+ * \returns 0 on success.
+ */
int
gmx_calc_cog(t_topology *top, rvec x[], int nrefat, atom_id index[], rvec xout);
/** Calculate a single center of mass. */
/** Calculate force on a single center of geometry. */
int
gmx_calc_cog_f(t_topology *top, rvec f[], int nrefat, atom_id index[], rvec fout);
-/** Calculate force on a single center of mass. */
+/*! \brief
+ * Calculate force on a single center of mass.
+ *
+ * \param[in] top Topology structure (unused, can be NULL).
+ * \param[in] f Forces on all atoms.
+ * \param[in] nrefat Number of atoms in the index.
+ * \param[in] index Indices of atoms.
+ * \param[out] fout Force on the COM position for the indexed atoms.
+ * \returns 0 on success.
+ */
int
gmx_calc_com_f(t_topology *top, rvec f[], int nrefat, atom_id index[], rvec fout);
/** Calculate a single center of mass/geometry. */
gmx_calc_comg_pbc(t_topology *top, rvec x[], t_pbc *pbc,
int nrefat, atom_id index[], bool bMass, rvec xout);
-/** Calculate centers of geometry for a blocked index. */
+/*! \brief
+ * Calculate centers of geometry for a blocked index.
+ *
+ * \param[in] top Topology structure (unused, can be NULL).
+ * \param[in] x Position vectors of all atoms.
+ * \param[in] block t_block structure that divides \p index into blocks.
+ * \param[in] index Indices of atoms.
+ * \param[out] xout \p block->nr COG positions.
+ * \returns 0 on success.
+ */
int
gmx_calc_cog_block(t_topology *top, rvec x[], t_block *block,
atom_id index[], rvec xout[]);
int
gmx_calc_cog_f_block(t_topology *top, rvec f[], t_block *block,
atom_id index[], rvec fout[]);
-/** Calculate forces on centers of mass for a blocked index. */
+/*! \brief
+ * Calculate forces on centers of mass for a blocked index.
+ *
+ * \param[in] top Topology structure (unused, can be NULL).
+ * \param[in] f Forces on all atoms.
+ * \param[in] block t_block structure that divides \p index into blocks.
+ * \param[in] index Indices of atoms.
+ * \param[out] fout \p block->nr Forces on COM positions.
+ * \returns 0 on success.
+ */
int
gmx_calc_com_f_block(t_topology *top, rvec f[], t_block *block,
atom_id index[], rvec fout[]);
}
}
-/*!
- * \param[in] data Data for the current frame.
- * \param[in] sel Selection element being evaluated.
- * \param[in] g Group for which \p sel should be evaluated
- * (not used, can be NULL).
- * \returns 0 on success, a non-zero error code on error.
- *
- * Evaluates the first child element in the group defined by \p sel->u.cgrp.
- * If \p sel->u.cgrp is empty, nothing is done.
- * The value of \p sel is not touched (root elements do not evaluate to
- * values).
- *
- * This function can be used as gmx::SelectionTreeElement::evaluate for
- * \ref SEL_ROOT elements.
- */
void
-_gmx_sel_evaluate_root(gmx_sel_evaluate_t *data,
- const SelectionTreeElementPointer &sel,
- gmx_ana_index_t *g)
+_gmx_sel_evaluate_root(gmx_sel_evaluate_t *data,
+ const gmx::SelectionTreeElementPointer &sel,
+ gmx_ana_index_t * /* g */)
{
if (sel->u.cgrp.isize == 0 || !sel->child->evaluate)
{
sel->u.cgrp.isize < 0 ? NULL : &sel->u.cgrp);
}
-/*!
- * \param[in] data Data for the current frame.
- * \param[in] sel Selection element being evaluated.
- * \param[in] g Group for which \p sel should be evaluated.
- * \returns 0 for success.
- *
- * Sets the value of \p sel to the intersection of \p g and \p sel->u.cgrp.
- *
- * This function can be used as gmx::SelectionTreeElement::evaluate for
- * \ref SEL_CONST elements with value type \ref GROUP_VALUE.
- */
void
-_gmx_sel_evaluate_static(gmx_sel_evaluate_t *data,
- const SelectionTreeElementPointer &sel,
- gmx_ana_index_t *g)
+_gmx_sel_evaluate_static(gmx_sel_evaluate_t * /* data */,
+ const gmx::SelectionTreeElementPointer &sel,
+ gmx_ana_index_t *g)
{
gmx_ana_index_intersection(sel->v.u.g, &sel->u.cgrp, g);
}
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2009,2010,2011,2012, by the GROMACS development team, led by
+ * Copyright (c) 2009,2010,2011,2012,2013, by the GROMACS development team, led by
* David van der Spoel, Berk Hess, Erik Lindahl, and including many
* others, as listed in the AUTHORS file in the top-level source
* directory and at http://www.gromacs.org.
/*! \name Misc. evaluation functions
*/
/*@{*/
-/** Evaluates a root selection element. */
+/*! \brief
+ * Evaluates a root selection element.
+ *
+ * \param[in] data Data for the current frame.
+ * \param[in] sel Selection element being evaluated.
+ * \param[in] g Group for which \p sel should be evaluated
+ * (not used, can be NULL).
+ * \returns 0 on success, a non-zero error code on error.
+ *
+ * Evaluates the first child element in the group defined by \p sel->u.cgrp.
+ * If \p sel->u.cgrp is empty, nothing is done.
+ * The value of \p sel is not touched (root elements do not evaluate to
+ * values).
+ *
+ * This function can be used as gmx::SelectionTreeElement::evaluate for
+ * \ref SEL_ROOT elements.
+ */
void
_gmx_sel_evaluate_root(gmx_sel_evaluate_t *data,
const gmx::SelectionTreeElementPointer &sel,
gmx_ana_index_t *g);
-/** Evaluates a static group selection element. */
+/*! \brief
+ * Evaluates a static group selection element.
+ *
+ * \param[in] data Data for the current frame.
+ * \param[in] sel Selection element being evaluated.
+ * \param[in] g Group for which \p sel should be evaluated.
+ * \returns 0 for success.
+ *
+ * Sets the value of \p sel to the intersection of \p g and \p sel->u.cgrp.
+ *
+ * This function can be used as gmx::SelectionTreeElement::evaluate for
+ * \ref SEL_CONST elements with value type \ref GROUP_VALUE.
+ */
void
_gmx_sel_evaluate_static(gmx_sel_evaluate_t *data,
const gmx::SelectionTreeElementPointer &sel,
}
}
-/*!
- * \param[in] left Selection element for the left hand side.
- * \param[in] right Selection element for the right hand side.
- * \param[in] op String representation of the operator.
- * \param[in] scanner Scanner data structure.
- * \returns The created selection element.
- *
- * This function handles the creation of a gmx::SelectionTreeElement object for
- * arithmetic expressions.
- */
-SelectionTreeElementPointer
-_gmx_sel_init_arithmetic(const SelectionTreeElementPointer &left,
- const SelectionTreeElementPointer &right,
- char op, yyscan_t scanner)
+gmx::SelectionTreeElementPointer
+_gmx_sel_init_arithmetic(const gmx::SelectionTreeElementPointer &left,
+ const gmx::SelectionTreeElementPointer &right,
+ char op, yyscan_t /* scanner */)
{
SelectionTreeElementPointer sel(new SelectionTreeElement(SEL_ARITHMETIC));
sel->v.type = REAL_VALUE;
_gmx_selelem_set_method(const gmx::SelectionTreeElementPointer &sel,
struct gmx_ana_selmethod_t *method, void *scanner);
-/** Creates a gmx::SelectionTreeElement for arithmetic expression evaluation. */
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+/** \brief Creates a gmx::SelectionTreeElement for arithmetic expression evaluation.
+ *
+ * \param[in] left Selection element for the left hand side.
+ * \param[in] right Selection element for the right hand side.
+ * \param[in] op String representation of the operator.
+ * \param[in] scanner Scanner data structure.
+ * \returns The created selection element.
+ *
+ * This function handles the creation of a gmx::SelectionTreeElement object for
+ * arithmetic expressions.
+ */
gmx::SelectionTreeElementPointer
_gmx_sel_init_arithmetic(const gmx::SelectionTreeElementPointer &left,
const gmx::SelectionTreeElementPointer &right,
- char op, void *scanner);
+ char op, yyscan_t scanner);
/** Creates a gmx::SelectionTreeElement for comparsion expression evaluation. */
gmx::SelectionTreeElementPointer
_gmx_sel_init_comparison(const gmx::SelectionTreeElementPointer &left,
#include "gromacs/legacyheaders/smalloc.h"
#include "gromacs/selection/selmethod.h"
+#include "gromacs/utility/common.h"
#include "gromacs/utility/exceptions.h"
/** Defines the comparison operator for comparison expressions. */
t_compare_value right;
} t_methoddata_compare;
-/** Allocates data for comparison expression evaluation. */
+/*! \brief
+ * Allocates data for comparison expression evaluation.
+ *
+ * \param[in] npar Not used (should be 5).
+ * \param[in,out] param Method parameters (should point to a copy of
+ * \ref smparams_compare).
+ * \returns Pointer to the allocated data (\c t_methoddata_compare).
+ *
+ * Allocates memory for a \c t_methoddata_compare structure.
+ */
static void *
init_data_compare(int npar, gmx_ana_selparam_t *param);
-/** Initializes data for comparison expression evaluation. */
+/*! \brief
+ * Initializes data for comparison expression evaluation.
+ *
+ * \param[in] top Not used.
+ * \param[in] npar Not used (should be 5).
+ * \param[in] param Method parameters (should point to \ref smparams_compare).
+ * \param[in] data Should point to a \c t_methoddata_compare.
+ * \returns 0 if the input data is valid, -1 on error.
+ */
static void
init_compare(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
/** Frees the memory allocated for comparison expression evaluation. */
fprintf(fp, "\"");
}
-/*!
- * \param[in] npar Not used (should be 5).
- * \param[in,out] param Method parameters (should point to a copy of
- * \ref smparams_compare).
- * \returns Pointer to the allocated data (\c t_methoddata_compare).
- *
- * Allocates memory for a \c t_methoddata_compare structure.
- */
static void *
-init_data_compare(int npar, gmx_ana_selparam_t *param)
+init_data_compare(int /* npar */, gmx_ana_selparam_t *param)
{
t_methoddata_compare *data;
val->flags |= CMP_ALLOCINT;
}
-/*!
- * \param[in] top Not used.
- * \param[in] npar Not used (should be 5).
- * \param[in] param Method parameters (should point to \ref smparams_compare).
- * \param[in] data Should point to a \c t_methoddata_compare.
- * \returns 0 if the input data is valid, -1 on error.
- */
static void
-init_compare(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_compare(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t *param, void *data)
{
t_methoddata_compare *d = (t_methoddata_compare *)data;
int n1, n2;
sfree(d);
}
-/*!
+/*! \brief
+ * Implementation for evaluate_compare() for integer values.
+ *
* \param[in] top Not used.
* \param[in] fr Not used.
* \param[in] pbc Not used.
int a, b;
bool bAccept;
+ GMX_UNUSED_VALUE(top);
+ GMX_UNUSED_VALUE(fr);
+ GMX_UNUSED_VALUE(pbc);
for (i = i1 = i2 = ig = 0; i < g->isize; ++i)
{
a = d->left.i[i1];
out->u.g->isize = ig;
}
-/*!
+/*! \brief
+ * Implementation for evaluate_compare() if either value is non-integer.
+ *
* \param[in] top Not used.
* \param[in] fr Not used.
* \param[in] pbc Not used.
* \param[in] g Evaluation index group.
* \param[out] out Output data structure (\p out->u.g is used).
* \param[in] data Should point to a \c t_methoddata_compare.
+ *
+ * Left value is assumed to be real-valued; right value can be either.
+ * This is ensured by the initialization method.
*/
static void
evaluate_compare_real(t_topology *top, t_trxframe *fr, t_pbc *pbc,
real a, b;
bool bAccept;
+ GMX_UNUSED_VALUE(top);
+ GMX_UNUSED_VALUE(fr);
+ GMX_UNUSED_VALUE(pbc);
for (i = i1 = i2 = ig = 0; i < g->isize; ++i)
{
a = d->left.r[i1];
gmx::AnalysisNeighborhoodSearch nbsearch;
};
-/** Allocates data for distance-based selection methods. */
+/*! \brief
+ * Allocates data for distance-based selection methods.
+ *
+ * \param[in] npar Not used (should be 2).
+ * \param[in,out] param Method parameters (should point to one of the distance
+ * parameter arrays).
+ * \returns Pointer to the allocated data (\c t_methoddata_distance).
+ *
+ * Allocates memory for a \c t_methoddata_distance structure and
+ * initializes the parameter as follows:
+ * - the first parameter defines the value for
+ * \c t_methoddata_distance::cutoff.
+ * - the second parameter defines the reference positions and the value is
+ * stored in \c t_methoddata_distance::p.
+ */
static void *
init_data_common(int npar, gmx_ana_selparam_t *param);
-/** Initializes a distance-based selection method. */
+/*! \brief
+ * Initializes a distance-based selection method.
+ *
+ * \param top Not used.
+ * \param npar Not used (should be 2).
+ * \param param Method parameters (should point to one of the distance
+ * parameter arrays).
+ * \param data Pointer to \c t_methoddata_distance to initialize.
+ * \returns 0 on success, a non-zero error code on failure.
+ *
+ * Initializes the neighborhood search data structure
+ * (\c t_methoddata_distance::nb).
+ * Also checks that the cutoff is valid.
+ */
static void
init_common(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
/** Frees the data allocated for a distance-based selection method. */
static void
free_data_common(void *data);
-/** Initializes the evaluation of a distance-based within selection method for a frame. */
+/*! \brief
+ * Initializes the evaluation of a distance-based within selection method for a
+ * frame.
+ *
+ * \param[in] top Not used.
+ * \param[in] fr Current frame.
+ * \param[in] pbc PBC structure.
+ * \param data Should point to a \c t_methoddata_distance.
+ * \returns 0 on success, a non-zero error code on error.
+ *
+ * Initializes the neighborhood search for the current frame.
+ */
static void
-init_frame_common(t_topology *top, t_trxframe *fr, t_pbc *pbc, void *data);
+init_frame_common(t_topology *top, t_trxframe * fr, t_pbc *pbc, void *data);
/** Evaluates the \p distance selection method. */
static void
-evaluate_distance(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_distance(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_pos_t *pos, gmx_ana_selvalue_t *out, void *data);
/** Evaluates the \p within selection method. */
static void
-evaluate_within(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_within(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_pos_t *pos, gmx_ana_selvalue_t *out, void *data);
/** Parameters for the \p distance selection method. */
{"within REAL of POS_EXPR", asize(help_distance), help_distance},
};
-/*!
- * \param[in] npar Not used (should be 2).
- * \param[in,out] param Method parameters (should point to one of the distance
- * parameter arrays).
- * \returns Pointer to the allocated data (\c t_methoddata_distance).
- *
- * Allocates memory for a \c t_methoddata_distance structure and
- * initializes the parameter as follows:
- * - the first parameter defines the value for
- * \c t_methoddata_distance::cutoff.
- * - the second parameter defines the reference positions and the value is
- * stored in \c t_methoddata_distance::p.
- */
static void *
-init_data_common(int npar, gmx_ana_selparam_t *param)
+init_data_common(int /* npar */, gmx_ana_selparam_t *param)
{
t_methoddata_distance *data = new t_methoddata_distance();
param[0].val.u.r = &data->cutoff;
return data;
}
-/*!
- * \param top Not used.
- * \param npar Not used (should be 2).
- * \param param Method parameters (should point to one of the distance
- * parameter arrays).
- * \param data Pointer to \c t_methoddata_distance to initialize.
- * \returns 0 on success, a non-zero error code on failure.
- *
- * Initializes the neighborhood search data structure
- * (\c t_methoddata_distance::nb).
- * Also checks that the cutoff is valid.
- */
static void
-init_common(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_common(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t *param, void *data)
{
t_methoddata_distance *d = (t_methoddata_distance *)data;
delete static_cast<t_methoddata_distance *>(data);
}
-/*!
- * \param[in] top Not used.
- * \param[in] fr Current frame.
- * \param[in] pbc PBC structure.
- * \param data Should point to a \c t_methoddata_distance.
- * \returns 0 on success, a non-zero error code on error.
- *
- * Initializes the neighborhood search for the current frame.
- */
static void
-init_frame_common(t_topology *top, t_trxframe *fr, t_pbc *pbc, void *data)
+init_frame_common(t_topology * /* top */, t_trxframe * /* fr */, t_pbc *pbc, void *data)
{
t_methoddata_distance *d = (t_methoddata_distance *)data;
* and puts them in \p out->u.r.
*/
static void
-evaluate_distance(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_distance(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_pos_t *pos, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_distance *d = (t_methoddata_distance *)data;
* \c t_methoddata_distance::xref and puts them in \p out.g.
*/
static void
-evaluate_within(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_within(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_pos_t *pos, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_distance *d = (t_methoddata_distance *)data;
t_spheresurfacebin *bin;
} t_methoddata_insolidangle;
-/** Allocates data for the \p insolidangle selection method. */
+/*! \brief
+ * Allocates data for the \p insolidangle selection method.
+ *
+ * \param[in] npar Not used (should be 3).
+ * \param[in,out] param Method parameters (should point to
+ * \ref smparams_insolidangle).
+ * \returns Pointer to the allocated data (\ref t_methoddata_insolidangle).
+ *
+ * Allocates memory for a \ref t_methoddata_insolidangle structure and
+ * initializes the parameter as follows:
+ * - \p center defines the value for t_methoddata_insolidangle::center.
+ * - \p span defines the value for t_methoddata_insolidangle::span.
+ * - \p cutoff defines the value for t_methoddata_insolidangle::angcut.
+ */
static void *
init_data_insolidangle(int npar, gmx_ana_selparam_t *param);
-/** Initializes the \p insolidangle selection method. */
+/*! \brief
+ * Initializes the \p insolidangle selection method.
+ *
+ * \param top Not used.
+ * \param npar Not used.
+ * \param param Not used.
+ * \param data Pointer to \ref t_methoddata_insolidangle to initialize.
+ * \returns 0 on success, -1 on failure.
+ *
+ * Converts t_methoddata_insolidangle::angcut to radians and allocates
+ * and allocates memory for the bins used during the evaluation.
+ */
static void
-init_insolidangle(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
+init_insolidangle(t_topology * top, int npar, gmx_ana_selparam_t * param, void *data);
/** Frees the data allocated for the \p insolidangle selection method. */
static void
free_data_insolidangle(void *data);
-/** Initializes the evaluation of the \p insolidangle selection method for a frame. */
+/*! \brief
+ * Initializes the evaluation of the \p insolidangle selection method for a frame.
+ *
+ * \param[in] top Not used.
+ * \param[in] fr Not used.
+ * \param[in] pbc PBC structure.
+ * \param data Should point to a \ref t_methoddata_insolidangle.
+ *
+ * Creates a lookup structure that enables fast queries of whether a point
+ * is within the solid angle or not.
+ */
static void
-init_frame_insolidangle(t_topology *top, t_trxframe *fr, t_pbc *pbc, void *data);
+init_frame_insolidangle(t_topology * top, t_trxframe * fr, t_pbc *pbc, void *data);
/** Internal helper function for evaluate_insolidangle(). */
static bool
accept_insolidangle(rvec x, t_pbc *pbc, void *data);
/** Evaluates the \p insolidangle selection method. */
static void
-evaluate_insolidangle(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_insolidangle(t_topology * /* top */, t_trxframe * /* fr */, t_pbc *pbc,
gmx_ana_pos_t *pos, gmx_ana_selvalue_t *out, void *data);
/** Calculates the distance between unit vectors. */
/** Adds a single reference point and updates the surface bins. */
static void
store_surface_point(t_methoddata_insolidangle *surf, rvec x);
-/** Optimizes the surface bins for faster searching. */
+/*! \brief
+ * Optimizes the surface bins for faster searching.
+ *
+ * \param[in,out] surf Surface data structure.
+ *
+ * Currently, this function does nothing.
+ */
static void
optimize_surface_points(t_methoddata_insolidangle *surf);
/** Estimates the area covered by the reference cones. */
asize(help_insolidangle), help_insolidangle},
};
-/*!
- * \param[in] npar Not used (should be 3).
- * \param[in,out] param Method parameters (should point to
- * \ref smparams_insolidangle).
- * \returns Pointer to the allocated data (\ref t_methoddata_insolidangle).
- *
- * Allocates memory for a \ref t_methoddata_insolidangle structure and
- * initializes the parameter as follows:
- * - \p center defines the value for t_methoddata_insolidangle::center.
- * - \p span defines the value for t_methoddata_insolidangle::span.
- * - \p cutoff defines the value for t_methoddata_insolidangle::angcut.
- */
static void *
-init_data_insolidangle(int npar, gmx_ana_selparam_t *param)
+init_data_insolidangle(int /* npar */, gmx_ana_selparam_t *param)
{
t_methoddata_insolidangle *data = new t_methoddata_insolidangle();
data->angcut = 5.0;
return data;
}
-/*!
- * \param top Not used.
- * \param npar Not used.
- * \param param Not used.
- * \param data Pointer to \ref t_methoddata_insolidangle to initialize.
- * \returns 0 on success, -1 on failure.
- *
- * Converts t_methoddata_insolidangle::angcut to radians and allocates
- * and allocates memory for the bins used during the evaluation.
- */
static void
-init_insolidangle(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_insolidangle(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t * /* param */, void *data)
{
t_methoddata_insolidangle *surf = (t_methoddata_insolidangle *)data;
int i, c;
delete d;
}
-/*!
- * \param[in] top Not used.
- * \param[in] fr Current frame.
- * \param[in] pbc PBC structure.
- * \param data Should point to a \ref t_methoddata_insolidangle.
- *
- * Creates a lookup structure that enables fast queries of whether a point
- * is within the solid angle or not.
- */
static void
-init_frame_insolidangle(t_topology *top, t_trxframe *fr, t_pbc *pbc, void *data)
+init_frame_insolidangle(t_topology * /* top */, t_trxframe * /* fr */, t_pbc *pbc, void *data)
{
t_methoddata_insolidangle *d = (t_methoddata_insolidangle *)data;
rvec dx;
* \c t_methoddata_insolidangle::center, and stores the result in \p out->u.g.
*/
static void
-evaluate_insolidangle(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_insolidangle(t_topology * /* top */, t_trxframe * /* fr */, t_pbc *pbc,
gmx_ana_pos_t *pos, gmx_ana_selvalue_t *out, void *data)
{
out->u.g->isize = 0;
}
}
-/*!
- * \param[in,out] surf Surface data structure.
- *
- * Currently, this function does nothing.
- */
static void
-optimize_surface_points(t_methoddata_insolidangle *surf)
+optimize_surface_points(t_methoddata_insolidangle * /* surf */)
{
/* TODO: Implement */
}
#include "scanner.h"
#include "selelem.h"
-/** Allocates data for integer keyword evaluation. */
+/*! \brief
+ * Allocates data for integer keyword evaluation.
+ *
+ * \param[in] npar Not used.
+ * \param param Not used.
+ * \returns Pointer to the allocated data (\ref t_methoddata_kwint).
+ *
+ * Allocates memory for a \ref t_methoddata_kwint structure.
+ */
static void *
-init_data_kwint(int npar, gmx_ana_selparam_t *param);
-/** Allocates data for real keyword evaluation. */
+init_data_kwint(int npar, gmx_ana_selparam_t * param);
+/*! \brief
+ * Allocates data for real keyword evaluation.
+ *
+ * \param[in] npar Not used.
+ * \param param Not used.
+ * \returns Pointer to the allocated data (\ref t_methoddata_kwreal).
+ *
+ * Allocates memory for a \ref t_methoddata_kwreal structure.
+ */
static void *
-init_data_kwreal(int npar, gmx_ana_selparam_t *param);
-/** Allocates data for string keyword evaluation. */
+init_data_kwreal(int npar, gmx_ana_selparam_t * param);
+/*! \brief
+ * Allocates data for string keyword evaluation.
+ *
+ * \param[in] npar Not used.
+ * \param param Not used.
+ * \returns Pointer to the allocated data (t_methoddata_kwstr).
+ *
+ * Allocates memory for a t_methoddata_kwstr structure.
+ */
static void *
-init_data_kwstr(int npar, gmx_ana_selparam_t *param);
-/** Initializes data for integer keyword evaluation. */
+init_data_kwstr(int npar, gmx_ana_selparam_t * param);
+/** /brief Initializes data for integer keyword evaluation.
+ *
+ * \param[in] top Not used.
+ * \param[in] npar Not used (should be 2).
+ * \param[in] param Method parameters (should point to \ref smparams_keyword_int).
+ * \param[in] data Should point to \ref t_methoddata_kwint.
+ */
static void
init_kwint(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
-/** Initializes data for real keyword evaluation. */
+/*! \brief
+ * Initializes data for real keyword evaluation.
+ *
+ * \param[in] top Not used.
+ * \param[in] npar Not used (should be 2).
+ * \param[in] param Method parameters (should point to \ref smparams_keyword_real).
+ * \param[in] data Should point to \ref t_methoddata_kwreal.
+ * \returns 0 (the initialization always succeeds).
+ */
static void
init_kwreal(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
-/** Initializes data for string keyword evaluation. */
+/*! \brief
+ * Initializes data for string keyword evaluation.
+ *
+ * \param[in] top Not used.
+ * \param[in] npar Not used (should be 2).
+ * \param[in] param Method parameters (should point to \ref smparams_keyword_str).
+ * \param[in] data Should point to t_methoddata_kwstr.
+ */
static void
init_kwstr(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
/** Frees the memory allocated for string keyword evaluation. */
free_data_kwstr(void *data);
/** Evaluates integer selection keywords. */
static void
-evaluate_keyword_int(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_keyword_int(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data);
/** Evaluates real selection keywords. */
static void
-evaluate_keyword_real(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_keyword_real(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data);
/** Evaluates string selection keywords. */
static void
-evaluate_keyword_str(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_keyword_str(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data);
/*! \internal \brief
{NULL, 0, NULL},
};
-/** Initializes keyword evaluation for an arbitrary group. */
+/*! \brief
+ * Initializes keyword evaluation for an arbitrary group.
+ *
+ * \param[in] top Not used.
+ * \param[in] npar Not used.
+ * \param[in] param Not used.
+ * \param[in] data Should point to \ref t_methoddata_kweval.
+ * \returns 0 on success, a non-zero error code on return.
+ *
+ * Calls the initialization method of the wrapped keyword.
+ */
static void
-init_kweval(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
-/** Initializes output for keyword evaluation in an arbitrary group. */
+init_kweval(t_topology *top, int npar, gmx_ana_selparam_t * param, void *data);
+/*! \brief
+ * Initializes output for keyword evaluation in an arbitrary group.
+ *
+ * \param[in] top Not used.
+ * \param[in,out] out Pointer to output data structure.
+ * \param[in,out] data Should point to \c t_methoddata_kweval.
+ * \returns 0 for success.
+ */
static void
init_output_kweval(t_topology *top, gmx_ana_selvalue_t *out, void *data);
/** Frees the data allocated for keyword evaluation in an arbitrary group. */
init_frame_kweval(t_topology *top, t_trxframe *fr, t_pbc *pbc, void *data);
/** Evaluates keywords in an arbitrary group. */
static void
-evaluate_kweval(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data);
+evaluate_kweval(t_topology *top, t_trxframe *fr, t_pbc *pbc, gmx_ana_index_t * /* g */, gmx_ana_selvalue_t *out, void *data);
/*! \internal \brief
* Data structure for keyword evaluation in arbitrary groups.
* INTEGER KEYWORD EVALUATION
********************************************************************/
-/*!
- * \param[in] npar Not used.
- * \param param Not used.
- * \returns Pointer to the allocated data (\ref t_methoddata_kwint).
- *
- * Allocates memory for a \ref t_methoddata_kwint structure.
- */
static void *
-init_data_kwint(int npar, gmx_ana_selparam_t *param)
+init_data_kwint(int /* npar */, gmx_ana_selparam_t * /* param */)
{
t_methoddata_kwint *data;
return data;
}
-/*!
- * \param[in] top Not used.
- * \param[in] npar Not used (should be 2).
- * \param[in] param Method parameters (should point to \ref smparams_keyword_int).
- * \param[in] data Should point to \ref t_methoddata_kwint.
- */
static void
-init_kwint(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_kwint(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t *param, void *data)
{
t_methoddata_kwint *d = (t_methoddata_kwint *)data;
* Matching atoms are stored in \p out->u.g.
*/
static void
-evaluate_keyword_int(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_keyword_int(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_kwint *d = (t_methoddata_kwint *)data;
* REAL KEYWORD EVALUATION
********************************************************************/
-/*!
- * \param[in] npar Not used.
- * \param param Not used.
- * \returns Pointer to the allocated data (\ref t_methoddata_kwreal).
- *
- * Allocates memory for a \ref t_methoddata_kwreal structure.
- */
static void *
-init_data_kwreal(int npar, gmx_ana_selparam_t *param)
+init_data_kwreal(int /* npar */, gmx_ana_selparam_t * /* param */)
{
t_methoddata_kwreal *data;
return data;
}
-/*!
- * \param[in] top Not used.
- * \param[in] npar Not used (should be 2).
- * \param[in] param Method parameters (should point to \ref smparams_keyword_real).
- * \param[in] data Should point to \ref t_methoddata_kwreal.
- * \returns 0 (the initialization always succeeds).
- */
static void
-init_kwreal(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_kwreal(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t *param, void *data)
{
t_methoddata_kwreal *d = (t_methoddata_kwreal *)data;
* Matching atoms are stored in \p out->u.g.
*/
static void
-evaluate_keyword_real(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_keyword_real(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_kwreal *d = (t_methoddata_kwreal *)data;
* STRING KEYWORD EVALUATION
********************************************************************/
-/*!
- * \param[in] npar Not used.
- * \param param Not used.
- * \returns Pointer to the allocated data (t_methoddata_kwstr).
- *
- * Allocates memory for a t_methoddata_kwstr structure.
- */
static void *
-init_data_kwstr(int npar, gmx_ana_selparam_t *param)
+init_data_kwstr(int /* npar */, gmx_ana_selparam_t * /* param */)
{
t_methoddata_kwstr *data = new t_methoddata_kwstr();
data->matchType = gmx::eStringMatchType_Auto;
d->matchType = matchType;
}
-/*!
- * \param[in] top Not used.
- * \param[in] npar Not used (should be 2).
- * \param[in] param Method parameters (should point to \ref smparams_keyword_str).
- * \param[in] data Should point to t_methoddata_kwstr.
- */
static void
-init_kwstr(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_kwstr(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t *param, void *data)
{
t_methoddata_kwstr *d = static_cast<t_methoddata_kwstr *>(data);
* Matching atoms are stored in \p out->u.g.
*/
static void
-evaluate_keyword_str(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_keyword_str(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_kwstr *d = static_cast<t_methoddata_kwstr *>(data);
* KEYWORD EVALUATION FOR ARBITRARY GROUPS
********************************************************************/
-/*!
- * \param[in] top Not used.
- * \param[in] npar Not used.
- * \param[in] param Not used.
- * \param[in] data Should point to \ref t_methoddata_kweval.
- * \returns 0 on success, a non-zero error code on return.
- *
- * Calls the initialization method of the wrapped keyword.
- */
static void
-init_kweval(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_kweval(t_topology *top, int /* npar */, gmx_ana_selparam_t * /* param */, void *data)
{
t_methoddata_kweval *d = (t_methoddata_kweval *)data;
d->kwmethod->init(top, 0, NULL, d->kwmdata);
}
-/*!
- * \param[in] top Not used.
- * \param[in,out] out Pointer to output data structure.
- * \param[in,out] data Should point to \c t_methoddata_kweval.
- * \returns 0 for success.
- */
static void
-init_output_kweval(t_topology *top, gmx_ana_selvalue_t *out, void *data)
+init_output_kweval(t_topology * /* top */, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_kweval *d = (t_methoddata_kweval *)data;
*/
static void
evaluate_kweval(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+ gmx_ana_index_t * /* g */, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_kweval *d = (t_methoddata_kweval *)data;
#include "gromacs/selection/position.h"
#include "gromacs/selection/selmethod.h"
+#include "gromacs/utility/common.h"
#include "gromacs/utility/exceptions.h"
/*! \internal \brief
/** Allocates data for the merging selection modifiers. */
static void *
init_data_merge(int npar, gmx_ana_selparam_t *param);
-/** Initializes data for the merging selection modifiers. */
+/*! \brief
+ * Initializes data for the merging selection modifiers.
+ *
+ * \param[in] top Not used.
+ * \param[in] npar Not used (should be 2 or 3).
+ * \param[in] param Method parameters (should point to \ref smparams_merge).
+ * \param[in] data Should point to a \p t_methoddata_merge.
+ * \returns 0 if everything is successful, -1 on error.
+ */
static void
init_merge(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
/** Initializes output for the \p merge selection modifier. */
/** Frees the memory allocated for the merging selection modifiers. */
static void
free_data_merge(void *data);
-/** Evaluates the \p merge selection modifier. */
+/*! \brief
+ * Evaluates the \p merge selection modifier.
+ *
+ * \param[in] top Not used.
+ * \param[in] fr Not used.
+ * \param[in] pbc Not used.
+ * \param[in] p Positions to merge (should point to \p data->p1).
+ * \param[out] out Output data structure (\p out->u.p is used).
+ * \param[in] data Should point to a \p t_methoddata_merge.
+ */
static void
evaluate_merge(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_pos_t *p, gmx_ana_selvalue_t *out, void *data);
-/** Evaluates the \p plus selection modifier. */
+ gmx_ana_pos_t * p, gmx_ana_selvalue_t *out, void *data);
+/*! \brief
+ * Evaluates the \p plus selection modifier.
+ *
+ * \param[in] top Not used.
+ * \param[in] fr Not used.
+ * \param[in] pbc Not used.
+ * \param[in] p Positions to merge (should point to \p data->p1).
+ * \param[out] out Output data structure (\p out->u.p is used).
+ * \param[in] data Should point to a \p t_methoddata_merge.
+ */
static void
evaluate_plus(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_pos_t *p, gmx_ana_selvalue_t *out, void *data);
+ gmx_ana_pos_t * p, gmx_ana_selvalue_t *out, void *data);
/** Parameters for the merging selection modifiers. */
static gmx_ana_selparam_t smparams_merge[] = {
return data;
}
-/*!
- * \param[in] top Not used.
- * \param[in] npar Not used (should be 2 or 3).
- * \param[in] param Method parameters (should point to \ref smparams_merge).
- * \param[in] data Should point to a \p t_methoddata_merge.
- * \returns 0 if everything is successful, -1 on error.
- */
static void
-init_merge(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_merge(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t * /* param */, void *data)
{
t_methoddata_merge *d = (t_methoddata_merge *)data;
{
t_methoddata_merge *d = (t_methoddata_merge *)data;
+ GMX_UNUSED_VALUE(top);
if (d->p1.m.type != d->p2.m.type)
{
/* TODO: Maybe we could pick something else here? */
delete d;
}
-/*!
- * \param[in] top Not used.
- * \param[in] fr Not used.
- * \param[in] pbc Not used.
- * \param[in] p Positions to merge (should point to \p data->p1).
- * \param[out] out Output data structure (\p out->u.p is used).
- * \param[in] data Should point to a \p t_methoddata_merge.
- */
static void
-evaluate_merge(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_pos_t *p, gmx_ana_selvalue_t *out, void *data)
+evaluate_merge(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_pos_t * /* p */, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_merge *d = (t_methoddata_merge *)data;
int i, j;
gmx_ana_pos_append_finish(out->u.p);
}
-/*!
- * \param[in] top Not used.
- * \param[in] fr Not used.
- * \param[in] pbc Not used.
- * \param[in] p Positions to merge (should point to \p data->p1).
- * \param[out] out Output data structure (\p out->u.p is used).
- * \param[in] data Should point to a \p t_methoddata_merge.
- */
static void
-evaluate_plus(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_pos_t *p, gmx_ana_selvalue_t *out, void *data)
+evaluate_plus(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_pos_t * /* p */, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_merge *d = (t_methoddata_merge *)data;
int i;
int *rperm;
} t_methoddata_permute;
-/** Allocates data for the \p permute selection modifier. */
+/*! \brief
+ * Allocates data for the \p permute selection modifier.
+ *
+ * \param[in] npar Not used (should be 2).
+ * \param[in,out] param Method parameters (should point to a copy of
+ * \ref smparams_permute).
+ * \returns Pointer to the allocated data (\p t_methoddata_permute).
+ *
+ * Allocates memory for a \p t_methoddata_permute structure.
+ */
static void *
init_data_permute(int npar, gmx_ana_selparam_t *param);
-/** Initializes data for the \p permute selection modifier. */
+/*! \brief
+ * Initializes data for the \p permute selection modifier.
+ *
+ * \param[in] top Not used.
+ * \param[in] npar Not used (should be 2).
+ * \param[in] param Method parameters (should point to \ref smparams_permute).
+ * \param[in] data Should point to a \p t_methoddata_permute.
+ * \returns 0 if the input permutation is valid, -1 on error.
+ */
static void
init_permute(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
-/** Initializes output for the \p permute selection modifier. */
+/*! \brief
+ * Initializes output for the \p permute selection modifier.
+ *
+ * \param[in] top Topology data structure.
+ * \param[in,out] out Pointer to output data structure.
+ * \param[in,out] data Should point to \c t_methoddata_permute.
+ */
static void
init_output_permute(t_topology *top, gmx_ana_selvalue_t *out, void *data);
/** Frees the memory allocated for the \p permute selection modifier. */
static void
free_data_permute(void *data);
-/** Evaluates the \p permute selection modifier. */
static void
+/*! \brief
+ * Evaluates the \p permute selection modifier.
+ *
+ * \param[in] top Not used.
+ * \param[in] fr Not used.
+ * \param[in] pbc Not used.
+ * \param[in] p Positions to permute (should point to \p data->p).
+ * \param[out] out Output data structure (\p out->u.p is used).
+ * \param[in] data Should point to a \p t_methoddata_permute.
+ * \returns 0 if \p p could be permuted, -1 on error.
+ *
+ * Returns -1 if the size of \p p is not divisible by the number of
+ * elements in the permutation.
+ */
evaluate_permute(t_topology *top, t_trxframe *fr, t_pbc *pbc,
gmx_ana_pos_t *p, gmx_ana_selvalue_t *out, void *data);
{"permute P1 ... PN", asize(help_permute), help_permute},
};
-/*!
- * \param[in] npar Not used (should be 2).
- * \param[in,out] param Method parameters (should point to a copy of
- * \ref smparams_permute).
- * \returns Pointer to the allocated data (\p t_methoddata_permute).
- *
- * Allocates memory for a \p t_methoddata_permute structure.
- */
static void *
-init_data_permute(int npar, gmx_ana_selparam_t *param)
+init_data_permute(int /* npar */, gmx_ana_selparam_t *param)
{
t_methoddata_permute *data = new t_methoddata_permute();
data->n = 0;
return data;
}
-/*!
- * \param[in] top Not used.
- * \param[in] npar Not used (should be 2).
- * \param[in] param Method parameters (should point to \ref smparams_permute).
- * \param[in] data Should point to a \p t_methoddata_permute.
- * \returns 0 if the input permutation is valid, -1 on error.
- */
static void
-init_permute(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_permute(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t *param, void *data)
{
t_methoddata_permute *d = (t_methoddata_permute *)data;
int i;
}
}
-/*!
- * \param[in] top Topology data structure.
- * \param[in,out] out Pointer to output data structure.
- * \param[in,out] data Should point to \c t_methoddata_permute.
- */
static void
-init_output_permute(t_topology *top, gmx_ana_selvalue_t *out, void *data)
+init_output_permute(t_topology * /* top */, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_permute *d = (t_methoddata_permute *)data;
int i, j, b;
delete d;
}
-/*!
- * \param[in] top Not used.
- * \param[in] fr Not used.
- * \param[in] pbc Not used.
- * \param[in] p Positions to permute (should point to \p data->p).
- * \param[out] out Output data structure (\p out->u.p is used).
- * \param[in] data Should point to a \p t_methoddata_permute.
- * \returns 0 if \p p could be permuted, -1 on error.
- *
- * Returns -1 if the size of \p p is not divisible by the number of
- * elements in the permutation.
- */
static void
-evaluate_permute(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_permute(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_pos_t *p, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_permute *d = (t_methoddata_permute *)data;
/** Sets the position calculation collection for position evaluation selection methods. */
static void
set_poscoll_pos(gmx::PositionCalculationCollection *pcc, void *data);
-/** Initializes position evaluation keywords. */
+/*! \brief
+ * Initializes position evaluation keywords.
+ *
+ * \param[in] top Not used.
+ * \param[in] npar Not used.
+ * \param[in] param Not used.
+ * \param[in,out] data Should point to \c t_methoddata_pos.
+ * \returns 0 on success, a non-zero error code on error.
+ *
+ * The \c t_methoddata_pos::type field should have been initialized
+ * externally using _gmx_selelem_set_kwpos_type().
+ */
static void
init_kwpos(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
-/** Initializes the \p cog selection method. */
+/*! Initializes the \p cog selection method.
+ *
+ * \param[in] top Topology data structure.
+ * \param[in] npar Not used.
+ * \param[in] param Not used.
+ * \param[in,out] data Should point to \c t_methoddata_pos.
+ * \returns 0 on success, a non-zero error code on error.
+ */
static void
init_cog(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
-/** Initializes the \p cog selection method. */
+/*! \brief
+ * Initializes the \p cog selection method.
+ *
+ * \param[in] top Topology data structure.
+ * \param[in] npar Not used.
+ * \param[in] param Not used.
+ * \param[in,out] data Should point to \c t_methoddata_pos.
+ * \returns 0 on success, a non-zero error code on error.
+ */
static void
init_com(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
-/** Initializes output for position evaluation selection methods. */
+/*! \brief
+ * Initializes output for position evaluation selection methods.
+ *
+ * \param[in] top Topology data structure.
+ * \param[in,out] out Pointer to output data structure.
+ * \param[in,out] data Should point to \c t_methoddata_pos.
+ * \returns 0 for success.
+ */
static void
init_output_pos(t_topology *top, gmx_ana_selvalue_t *out, void *data);
/** Frees the data allocated for position evaluation selection methods. */
free_data_pos(void *data);
/** Evaluates position evaluation selection methods. */
static void
-evaluate_pos(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data);
+evaluate_pos(t_topology * /* top */, t_trxframe *fr, t_pbc *pbc, gmx_ana_index_t * /* g */, gmx_ana_selvalue_t *out, void *data);
/** Parameters for position keyword evaluation. */
static gmx_ana_selparam_t smparams_keyword_pos[] = {
}
}
-/*!
- * \param[in] top Not used.
- * \param[in] npar Not used.
- * \param[in] param Not used.
- * \param[in,out] data Should point to \c t_methoddata_pos.
- * \returns 0 on success, a non-zero error code on error.
- *
- * The \c t_methoddata_pos::type field should have been initialized
- * externally using _gmx_selelem_set_kwpos_type().
- */
static void
-init_kwpos(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_kwpos(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t *param, void *data)
{
t_methoddata_pos *d = (t_methoddata_pos *)data;
gmx_ana_poscalc_set_maxindex(d->pc, &d->g);
}
-/*!
- * \param[in] top Topology data structure.
- * \param[in] npar Not used.
- * \param[in] param Not used.
- * \param[in,out] data Should point to \c t_methoddata_pos.
- * \returns 0 on success, a non-zero error code on error.
- */
static void
-init_cog(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_cog(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t *param, void *data)
{
t_methoddata_pos *d = (t_methoddata_pos *)data;
gmx_ana_poscalc_set_maxindex(d->pc, &d->g);
}
-/*!
- * \param[in] top Topology data structure.
- * \param[in] npar Not used.
- * \param[in] param Not used.
- * \param[in,out] data Should point to \c t_methoddata_pos.
- * \returns 0 on success, a non-zero error code on error.
- */
static void
-init_com(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_com(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t *param, void *data)
{
t_methoddata_pos *d = (t_methoddata_pos *)data;
gmx_ana_poscalc_set_maxindex(d->pc, &d->g);
}
-/*!
- * \param[in] top Topology data structure.
- * \param[in,out] out Pointer to output data structure.
- * \param[in,out] data Should point to \c t_methoddata_pos.
- * \returns 0 for success.
- */
static void
-init_output_pos(t_topology *top, gmx_ana_selvalue_t *out, void *data)
+init_output_pos(t_topology * /* top */, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_pos *d = (t_methoddata_pos *)data;
* in \c t_methoddata_pos::g and stores the results in \p out->u.p.
*/
static void
-evaluate_pos(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_pos(t_topology * /* top */, t_trxframe *fr, t_pbc *pbc,
+ gmx_ana_index_t * /* g */, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_pos *d = (t_methoddata_pos *)data;
bool bSorted;
} t_methoddata_same;
-/** Allocates data for the \p same selection method. */
+/*! \brief
+ * Allocates data for the \p same selection method.
+ *
+ * \param[in] npar Not used (should be 2).
+ * \param[in,out] param Method parameters (should point to a copy of
+ * ::smparams_same_int or ::smparams_same_str).
+ * \returns Pointer to the allocated data (\ref t_methoddata_same).
+ */
static void *
init_data_same(int npar, gmx_ana_selparam_t *param);
-/** Initializes the \p same selection method. */
+/*! Initializes the \p same selection method.
+ *
+ * \param top Not used.
+ * \param npar Not used (should be 2).
+ * \param param Initialized method parameters (should point to a copy of
+ * ::smparams_same_int or ::smparams_same_str).
+ * \param data Pointer to \ref t_methoddata_same to initialize.
+ * \returns 0 on success, -1 on failure.
+ */
static void
init_same(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
/** Frees the data allocated for the \p same selection method. */
static void
free_data_same(void *data);
-/** Initializes the evaluation of the \p same selection method for a frame. */
+/*! \brief
+ * Initializes the evaluation of the \p same selection method for a frame.
+ *
+ * \param[in] top Not used.
+ * \param[in] fr Current frame.
+ * \param[in] pbc PBC structure.
+ * \param data Should point to a \ref t_methoddata_same.
+ *
+ * Sorts the \c data->as.i array and removes identical values for faster and
+ * simpler lookup.
+ */
static void
init_frame_same_int(t_topology *top, t_trxframe *fr, t_pbc *pbc, void *data);
/** Evaluates the \p same selection method. */
static void
-evaluate_same_int(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_same_int(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data);
-/** Initializes the evaluation of the \p same selection method for a frame. */
+/*! \brief
+ * Initializes the evaluation of the \p same selection method for a frame.
+ *
+ * \param[in] top Not used.
+ * \param[in] fr Current frame.
+ * \param[in] pbc PBC structure.
+ * \param data Should point to a \ref t_methoddata_same.
+ *
+ * Sorts the \c data->as.s array and removes identical values for faster and
+ * simpler lookup.
+ */
static void
init_frame_same_str(t_topology *top, t_trxframe *fr, t_pbc *pbc, void *data);
/** Evaluates the \p same selection method. */
static void
-evaluate_same_str(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_same_str(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data);
/** Parameters for the \p same selection method. */
{"same KEYWORD as ATOM_EXPR", asize(help_same), help_same},
};
-/*!
- * \param[in] npar Not used (should be 2).
- * \param[in,out] param Method parameters (should point to a copy of
- * ::smparams_same_int or ::smparams_same_str).
- * \returns Pointer to the allocated data (\ref t_methoddata_same).
- */
static void *
-init_data_same(int npar, gmx_ana_selparam_t *param)
+init_data_same(int /* npar */, gmx_ana_selparam_t *param)
{
t_methoddata_same *data;
return 0;
}
-/*!
- * \param top Not used.
- * \param npar Not used (should be 2).
- * \param param Initialized method parameters (should point to a copy of
- * ::smparams_same_int or ::smparams_same_str).
- * \param data Pointer to \ref t_methoddata_same to initialize.
- * \returns 0 on success, -1 on failure.
- */
static void
-init_same(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+init_same(t_topology * /* top */, int /* npar */, gmx_ana_selparam_t *param, void *data)
{
t_methoddata_same *d = (t_methoddata_same *)data;
return 0;
}
-/*!
- * \param[in] top Not used.
- * \param[in] fr Current frame.
- * \param[in] pbc PBC structure.
- * \param data Should point to a \ref t_methoddata_same.
- *
- * Sorts the \c data->as.i array and removes identical values for faster and
- * simpler lookup.
- */
static void
-init_frame_same_int(t_topology *top, t_trxframe *fr, t_pbc *pbc, void *data)
+init_frame_same_int(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */, void *data)
{
t_methoddata_same *d = (t_methoddata_same *)data;
int i, j;
* \c data->val.
*/
static void
-evaluate_same_int(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_same_int(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_same *d = (t_methoddata_same *)data;
return strcmp(*(char **)a, *(char **)b);
}
-/*!
- * \param[in] top Not used.
- * \param[in] fr Current frame.
- * \param[in] pbc PBC structure.
- * \param data Should point to a \ref t_methoddata_same.
- *
- * Sorts the \c data->as.s array and removes identical values for faster and
- * simpler lookup.
- */
static void
-init_frame_same_str(t_topology *top, t_trxframe *fr, t_pbc *pbc, void *data)
+init_frame_same_str(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */, void *data)
{
t_methoddata_same *d = (t_methoddata_same *)data;
int i, j;
* \c data->val.
*/
static void
-evaluate_same_str(t_topology *top, t_trxframe *fr, t_pbc *pbc,
+evaluate_same_str(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
{
t_methoddata_same *d = (t_methoddata_same *)data;
static void
evaluate_resindex(t_topology *top, t_trxframe *fr, t_pbc *pbc,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data);
-/** Checks whether molecule information is present in the topology. */
+/*! \brief
+ * Checks whether molecule information is present in the topology.
+ *
+ * \param[in] top Topology structure.
+ * \param npar Not used.
+ * \param param Not used.
+ * \param data Not used.
+ * \returns 0 if molecule info is present in the topology, -1 otherwise.
+ *
+ * If molecule information is not found, also prints an error message.
+ */
static void
check_molecules(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
/** Evaluates the \p molindex selection keyword. */
static void
evaluate_pdbatomname(t_topology *top, t_trxframe *fr, t_pbc *pbc,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data);
-/** Checks whether atom types are present in the topology. */
+/*! \brief
+ * Checks whether atom types are present in the topology.
+ *
+ * \param[in] top Topology structure.
+ * \param npar Not used.
+ * \param param Not used.
+ * \param data Not used.
+ * \returns 0 if atom types are present in the topology, -1 otherwise.
+ *
+ * If the atom types are not found, also prints an error message.
+ */
static void
check_atomtype(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
/** Evaluates the \p atomtype selection keyword. */
static void
evaluate_charge(t_topology *top, t_trxframe *fr, t_pbc *pbc,
gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data);
-/** Checks whether PDB info is present in the topology. */
+/*! \brief
+ * Checks whether PDB info is present in the topology.
+ *
+ * \param[in] top Topology structure.
+ * \param npar Not used.
+ * \param param Not used.
+ * \param data Not used.
+ * \returns 0 if PDB info is present in the topology, -1 otherwise.
+ *
+ * If PDB info is not found, also prints an error message.
+ */
static void
check_pdbinfo(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data);
/** Evaluates the \p altloc selection keyword. */
* Copies \p g to \p out->u.g.
*/
static void
-evaluate_all(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_all(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
gmx_ana_index_copy(out->u.g, g, false);
}
* Returns an empty \p out->u.g.
*/
static void
-evaluate_none(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_none(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t * /* g */, gmx_ana_selvalue_t *out, void * /* data */)
{
out->u.g->isize = 0;
}
* Returns the indices for each atom in \p out->u.i.
*/
static void
-evaluate_atomnr(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_atomnr(t_topology * /* top */, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
* Returns the residue numbers for each atom in \p out->u.i.
*/
static void
-evaluate_resnr(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_resnr(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
int resind;
* Returns the residue indices for each atom in \p out->u.i.
*/
static void
-evaluate_resindex(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_resindex(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
}
}
-/*!
- * \param[in] top Topology structure.
- * \param npar Not used.
- * \param param Not used.
- * \param data Not used.
- * \returns 0 if molecule info is present in the topology, -1 otherwise.
- *
- * If molecule information is not found, also prints an error message.
- */
static void
-check_molecules(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+check_molecules(t_topology *top, int /* npar */, gmx_ana_selparam_t * /* param */, void * /* data */)
{
bool bOk;
* Returns the molecule indices for each atom in \p out->u.i.
*/
static void
-evaluate_molindex(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_molindex(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i, j;
* Returns the atom name for each atom in \p out->u.s.
*/
static void
-evaluate_atomname(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_atomname(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
* Returns the PDB atom name for each atom in \p out->u.s.
*/
static void
-evaluate_pdbatomname(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_pdbatomname(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
}
}
-/*!
- * \param[in] top Topology structure.
- * \param npar Not used.
- * \param param Not used.
- * \param data Not used.
- * \returns 0 if atom types are present in the topology, -1 otherwise.
- *
- * If the atom types are not found, also prints an error message.
- */
static void
-check_atomtype(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+check_atomtype(t_topology *top, int /* npar */, gmx_ana_selparam_t * /* param */, void * /* data */)
{
bool bOk;
* Segfaults if atom types are not found in the topology.
*/
static void
-evaluate_atomtype(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_atomtype(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
* Returns the residue name for each atom in \p out->u.s.
*/
static void
-evaluate_resname(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_resname(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
int resind;
* Returns the insertion code for each atom in \p out->u.s.
*/
static void
-evaluate_insertcode(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_insertcode(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
int resind;
* Returns the chain for each atom in \p out->u.s.
*/
static void
-evaluate_chain(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_chain(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
int resind;
* Returns the mass for each atom in \p out->u.r.
*/
static void
-evaluate_mass(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_mass(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
* Returns the charge for each atom in \p out->u.r.
*/
static void
-evaluate_charge(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_charge(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
}
}
-/*!
- * \param[in] top Topology structure.
- * \param npar Not used.
- * \param param Not used.
- * \param data Not used.
- * \returns 0 if PDB info is present in the topology, -1 otherwise.
- *
- * If PDB info is not found, also prints an error message.
- */
static void
-check_pdbinfo(t_topology *top, int npar, gmx_ana_selparam_t *param, void *data)
+check_pdbinfo(t_topology *top, int /* npar */, gmx_ana_selparam_t * /* param */, void * /* data */)
{
bool bOk;
* Returns the alternate location identifier for each atom in \p out->u.s.
*/
static void
-evaluate_altloc(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_altloc(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
* Segfaults if PDB info is not found in the topology.
*/
static void
-evaluate_occupancy(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_occupancy(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
* Segfaults if PDB info is not found in the topology.
*/
static void
-evaluate_betafactor(t_topology *top, t_trxframe *fr, t_pbc *pbc,
- gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void *data)
+evaluate_betafactor(t_topology *top, t_trxframe * /* fr */, t_pbc * /* pbc */,
+ gmx_ana_index_t *g, gmx_ana_selvalue_t *out, void * /* data */)
{
int i;
void
TrajectoryAnalysisCommandLineRunner::setSelectionDebugLevel(int debuglevel)
{
- impl_->debugLevel_ = 1;
+ impl_->debugLevel_ = debuglevel;
}
*
* This is intended only for use by internal debugging tools.
*
+ * \param[in] debuglevel Level of debugging verbosity.
+ *
* Does not throw.
*
* \see SelectionCollection::setDebugLevel()
void
-Angle::optionsFinished(Options *options, TrajectoryAnalysisSettings *settings)
+Angle::optionsFinished(Options *options, TrajectoryAnalysisSettings * /* settings */)
{
bool bSingle = (g1type_[0] == 'a' || g1type_[0] == 'd');
void
Angle::initAnalysis(const TrajectoryAnalysisSettings &settings,
- const TopologyInformation &top)
+ const TopologyInformation & /* top */)
{
checkSelections(sel1_, sel2_);
void
-FreeVolume::finishAnalysis(int nframes)
+FreeVolume::finishAnalysis(int /* nframes */)
{
please_cite(stdout, "Bondi1964a");
please_cite(stdout, "Lourenco2013a");
void
-Select::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc,
+Select::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc * /* pbc */,
TrajectoryAnalysisModuleData *pdata)
{
AnalysisDataHandle sdh = pdata->dataHandle(sdata_);
*/
#define GMX_IGNORE_RETURN_VALUE(call) \
::gmx::internal::ignoreValueHelper(call)
+/*! \brief
+ * Macro to explicitly ignore an unused value.
+ *
+ * \ingroup module_utility
+ */
+#define GMX_UNUSED_VALUE(value) (void)value
/*! \brief
* Helper class to manage a pointer to a private implementation class.
//! Returns the error in column \p i.
real error(int i) const { return values_[i].error; }
//! Returns whether the value in column \p i is present.
- bool present(int i) const { return true; }
+ bool present(int /*i*/) const { return true; }
//! Returns an AnalysisDataValue for column \p i.
AnalysisDataValue value(int i) const
{
void
MockAnalysisDataModule::setupStaticColumnCheck(
const AnalysisDataTestInput &data,
- int firstcol, int n, AbstractAnalysisData *source)
+ int firstcol, int n, AbstractAnalysisData * /*source*/)
{
impl_->flags_ |= efAllowMulticolumn | efAllowMultipoint | efAllowMultipleDataSets;
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff