2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 2009,2010,2011,2012,2013, by the GROMACS development team, led by
5 * David van der Spoel, Berk Hess, Erik Lindahl, and including many
6 * others, as listed in the AUTHORS file in the top-level source
7 * directory and at http://www.gromacs.org.
9 * GROMACS is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public License
11 * as published by the Free Software Foundation; either version 2.1
12 * of the License, or (at your option) any later version.
14 * GROMACS is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with GROMACS; if not, see
21 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 * If you want to redistribute modifications to GROMACS, please
25 * consider that scientific software is very special. Version
26 * control is crucial - bugs must be traceable. We will be happy to
27 * consider code for inclusion in the official distribution, but
28 * derived work must not be called official GROMACS. Details are found
29 * in the README & COPYING files - if they are missing, get the
30 * official version at http://www.gromacs.org.
32 * To help us fund GROMACS development, we humbly ask that you cite
33 * the research papers on the package. Check out http://www.gromacs.org.
37 * Implements functions in position.h.
39 * \author Teemu Murtola <teemu.murtola@gmail.com>
40 * \ingroup module_selection
44 #include "gromacs/legacyheaders/smalloc.h"
45 #include "gromacs/legacyheaders/typedefs.h"
46 #include "gromacs/legacyheaders/vec.h"
48 #include "gromacs/selection/indexutil.h"
49 #include "gromacs/selection/position.h"
50 #include "gromacs/utility/gmxassert.h"
53 * \param[out] pos Output structure.
55 * Any contents of \p pos are discarded without freeing.
58 gmx_ana_pos_clear(gmx_ana_pos_t *pos)
64 gmx_ana_indexmap_clear(&pos->m);
70 * \param[in,out] pos Position data structure.
71 * \param[in] n Maximum number of positions.
72 * \param[in] isize Maximum number of atoms.
74 * Ensures that enough memory is allocated in \p pos to calculate \p n
75 * positions from \p isize atoms.
78 gmx_ana_pos_reserve(gmx_ana_pos_t *pos, int n, int isize)
80 GMX_RELEASE_ASSERT(n >= 0, "Invalid position allocation count");
81 // Always reserve at least one entry to make NULL checks against pos->x
82 // and gmx_ana_pos_reserve_velocities/forces() work as expected in the case
83 // that there are actually no positions.
88 if (pos->nalloc_x < n)
103 gmx_ana_indexmap_reserve(&pos->m, n, isize);
108 * \param[in,out] pos Position data structure.
110 * Currently, this function can only be called after gmx_ana_pos_reserve()
111 * has been called at least once with a \p n >= 0.
114 gmx_ana_pos_reserve_velocities(gmx_ana_pos_t *pos)
116 GMX_RELEASE_ASSERT(pos->nalloc_x > 0,
117 "No memory reserved yet for positions");
120 snew(pos->v, pos->nalloc_x);
125 * \param[in,out] pos Position data structure.
127 * Currently, this function can only be called after gmx_ana_pos_reserve()
128 * has been called at least once with a \p n >= 0.
131 gmx_ana_pos_reserve_forces(gmx_ana_pos_t *pos)
133 GMX_RELEASE_ASSERT(pos->nalloc_x > 0,
134 "No memory reserved yet for positions");
137 snew(pos->f, pos->nalloc_x);
142 * \param[out] pos Position data structure to initialize.
143 * \param[in] x Position vector to use.
146 gmx_ana_pos_init_const(gmx_ana_pos_t *pos, const rvec x)
148 gmx_ana_pos_clear(pos);
154 copy_rvec(x, pos->x[0]);
155 clear_rvec(pos->v[0]);
156 clear_rvec(pos->f[0]);
157 gmx_ana_indexmap_init(&pos->m, NULL, NULL, INDEX_UNKNOWN);
161 * \param[in,out] pos Position data structure.
163 * Frees any memory allocated within \p pos.
164 * The pointer \p pos itself is not freed.
166 * \see gmx_ana_pos_free()
169 gmx_ana_pos_deinit(gmx_ana_pos_t *pos)
172 sfree(pos->x); pos->x = NULL;
173 sfree(pos->v); pos->v = NULL;
174 sfree(pos->f); pos->f = NULL;
176 gmx_ana_indexmap_deinit(&pos->m);
180 * \param[in,out] pos Position data structure.
182 * Frees any memory allocated for \p pos.
183 * The pointer \p pos is also freed, and is invalid after the call.
185 * \see gmx_ana_pos_deinit()
188 gmx_ana_pos_free(gmx_ana_pos_t *pos)
190 gmx_ana_pos_deinit(pos);
195 * \param[in,out] dest Destination positions.
196 * \param[in] src Source positions.
197 * \param[in] bFirst If true, memory is allocated for \p dest and a full
198 * copy is made; otherwise, only variable parts are copied, and no memory
201 * \p dest should have been initialized somehow (calloc() is enough).
204 gmx_ana_pos_copy(gmx_ana_pos_t *dest, gmx_ana_pos_t *src, bool bFirst)
208 gmx_ana_pos_reserve(dest, src->nr, 0);
211 gmx_ana_pos_reserve_velocities(dest);
215 gmx_ana_pos_reserve_forces(dest);
219 memcpy(dest->x, src->x, dest->nr*sizeof(*dest->x));
222 GMX_ASSERT(src->v, "src velocities should be non-null if dest velocities are allocated");
223 memcpy(dest->v, src->v, dest->nr*sizeof(*dest->v));
227 GMX_ASSERT(src->f, "src forces should be non-null if dest forces are allocated");
228 memcpy(dest->f, src->f, dest->nr*sizeof(*dest->f));
230 gmx_ana_indexmap_copy(&dest->m, &src->m, bFirst);
235 * \param[in,out] pos Position data structure.
236 * \param[in] nr Number of positions.
239 gmx_ana_pos_set_nr(gmx_ana_pos_t *pos, int nr)
245 * \param[in,out] pos Position data structure.
246 * \param g Evaluation group.
248 * The old group, if any, is discarded.
249 * Note that only a pointer to \p g is stored; it is the responsibility of
250 * the caller to ensure that \p g is not freed while it can be accessed
254 gmx_ana_pos_set_evalgrp(gmx_ana_pos_t *pos, gmx_ana_index_t *g)
260 * \param[in,out] pos Position data structure.
262 * Sets the number of positions to 0.
265 gmx_ana_pos_empty_init(gmx_ana_pos_t *pos)
272 /* This should not really be necessary, but do it for safety... */
273 pos->m.mapb.index[0] = 0;
274 pos->m.b.index[0] = 0;
275 /* This function should only be used to construct all the possible
276 * positions, so the result should always be static. */
277 pos->m.bStatic = true;
278 pos->m.bMapStatic = true;
282 * \param[in,out] pos Position data structure.
284 * Sets the number of positions to 0.
287 gmx_ana_pos_empty(gmx_ana_pos_t *pos)
292 /* This should not really be necessary, but do it for safety... */
293 pos->m.mapb.index[0] = 0;
294 /* We set the flags to true, although really in the empty state they
295 * should be false. This makes it possible to update the flags in
296 * gmx_ana_pos_append(), and just make a simple check in
297 * gmx_ana_pos_append_finish(). */
298 pos->m.bStatic = true;
299 pos->m.bMapStatic = true;
303 * \param[in,out] dest Data structure to which the new position is appended.
304 * \param[in,out] g Data structure to which the new atoms are appended.
305 * \param[in] src Data structure from which the position is copied.
306 * \param[in] i Index in \p from to copy.
309 gmx_ana_pos_append_init(gmx_ana_pos_t *dest, gmx_ana_index_t *g,
310 gmx_ana_pos_t *src, int i)
315 copy_rvec(src->x[i], dest->x[j]);
320 copy_rvec(src->v[i], dest->v[j]);
324 clear_rvec(dest->v[j]);
331 copy_rvec(src->f[i], dest->f[j]);
335 clear_rvec(dest->f[j]);
338 dest->m.refid[j] = j;
339 dest->m.mapid[j] = src->m.mapid[i];
340 dest->m.orgid[j] = src->m.orgid[i];
341 for (k = src->m.mapb.index[i]; k < src->m.mapb.index[i+1]; ++k)
343 g->index[g->isize++] = src->g->index[k];
344 dest->m.b.a[dest->m.b.nra++] = src->m.b.a[k];
346 dest->m.mapb.index[j+1] = g->isize;
347 dest->m.b.index[j+1] = g->isize;
349 dest->m.nr = dest->nr;
350 dest->m.mapb.nr = dest->nr;
351 dest->m.b.nr = dest->nr;
355 * \param[in,out] dest Data structure to which the new position is appended
356 * (can be NULL, in which case only \p g is updated).
357 * \param[in,out] g Data structure to which the new atoms are appended.
358 * \param[in] src Data structure from which the position is copied.
359 * \param[in] i Index in \p src to copy.
360 * \param[in] refid Reference ID in \p out
361 * (all negative values are treated as -1).
363 * If \p dest is NULL, the value of \p refid is not used.
366 gmx_ana_pos_append(gmx_ana_pos_t *dest, gmx_ana_index_t *g,
367 gmx_ana_pos_t *src, int i, int refid)
371 for (k = src->m.mapb.index[i]; k < src->m.mapb.index[i+1]; ++k)
373 g->index[g->isize++] = src->g->index[k];
382 copy_rvec(src->v[i], dest->v[j]);
386 clear_rvec(dest->v[j]);
393 copy_rvec(src->f[i], dest->f[j]);
397 clear_rvec(dest->f[j]);
400 copy_rvec(src->x[i], dest->x[j]);
403 dest->m.refid[j] = -1;
404 dest->m.bStatic = false;
405 /* If we are using masks, there is no need to alter the
412 dest->m.bStatic = false;
413 dest->m.bMapStatic = false;
415 dest->m.refid[j] = refid;
416 /* Use the original IDs from the output structure to correctly
417 * handle user customization. */
418 dest->m.mapid[j] = dest->m.orgid[refid];
420 dest->m.mapb.index[j+1] = g->isize;
422 dest->m.nr = dest->nr;
423 dest->m.mapb.nr = dest->nr;
428 * \param[in,out] pos Position data structure.
430 * After gmx_ana_pos_empty(), internal state of the position data structure
431 * is not consistent before this function is called. This function should be
432 * called after any gmx_ana_pos_append() calls have been made.
435 gmx_ana_pos_append_finish(gmx_ana_pos_t *pos)
437 if (pos->m.nr != pos->m.b.nr)
439 pos->m.bStatic = false;
440 pos->m.bMapStatic = false;