tfSpace.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of mdcore.
 * Coypright (c) 2010 Pedro Gonnet (pedro.gonnet@durham.ac.uk)
 * Coypright (c) 2017 Andy Somogyi (somogyie at indiana dot edu)
 * Copyright (c) 2022-2024 T.J. Sego
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

 
#ifndef _MDCORE_INCLUDE_TFSPACE_H_
#define _MDCORE_INCLUDE_TFSPACE_H_
#include <mdcore_config.h>
#include "tfSpace_cell.h"
 
#include <vector>
 
 
#define space_partlist_incr             100

#define space_maxtuples                 4

#define space_verlet_maxpairs           800
 
/* some useful macros */
#define space_cellid(s,i,j,k)           (  ((i)*(s)->cdim[1] + (j)) * (s)->cdim[2] + (k) )
#define celldims_cellid(cdim,i,j,k)     (  ((i)*cdim[1] + (j)) * cdim[2] + (k) )

#define space_pairind(i,j)              ( space_maxtuples*(i) - (i)*((i)+1)/2 + (j) )
 
 
namespace TissueForge { 
 
 
    /* some constants */
    enum PeriodicFlags {
        space_periodic_none       = 0,
        space_periodic_x          = 1 << 0,
        space_periodic_y          = 1 << 1,
        space_periodic_z          = 1 << 2,
        space_periodic_full       = (1 << 0) | (1 << 1) | (1 << 2),
        space_periodic_ghost_x    = 1 << 3,
        space_periodic_ghost_y    = 1 << 4,
        space_periodic_ghost_z    = 1 << 5,
        space_periodic_ghost_full = (1 << 3) | (1 << 4) | (1 << 5),
        SPACE_FREESLIP_X          = 1 << 6,
        SPACE_FREESLIP_Y          = 1 << 7,
        SPACE_FREESLIP_Z          = 1 << 8,
        SPACE_FREESLIP_FULL       = (1 << 6) | (1 << 7) | (1 << 8),
    };
 

    struct verlet_entry {

        struct Particle *p;

        struct Potential *pot;

        signed char shift[3];
 
    };

    struct cellpair {

        int i, j;

        FPTYPE shift[3];

        int size, count;
        short int *pairs;
        short int *nr_pairs;

        struct cellpair *next;
 
    };

    struct celltuple {

        int cellid[ space_maxtuples ];

        int n;

        int pairid[ space_maxtuples * (space_maxtuples + 1) / 2 ];
 
        /* Buffer value to keep the size at 64 bytes for space_maxtuples==4. */
        int buff;
 
    };

    typedef struct space {
        FPTYPE dim[3];

        FPTYPE origin[3];

        int cdim[3];

        int span[3];

        FPTYPE h[3], ih[3];

        FPTYPE cutoff, cutoff2;

        unsigned int period;

        int nr_cells;

        int *cid_real, *cid_ghost, *cid_marked;
        int nr_real, nr_ghost, nr_marked;

        struct space_cell *cells;

        int nr_tasks, tasks_size;

        struct task *tasks;

        pthread_mutex_t tasks_mutex;
        pthread_cond_t tasks_avail;

        char *cells_taboo;

        char *cells_owner;

        int nr_swaps, nr_stalls;

        struct Particle **partlist;

        space_cell largeparts;

        struct space_cell **celllist;

        int nr_parts, size_parts;

        int nr_visible_parts;
        int nr_visible_large_parts;

        int verlet_rebuild;

        FPTYPE maxdx;

        FPTYPE epot, epot_nonbond, epot_bond, epot_angle, epot_dihedral, epot_exclusion;

        struct verlet_entry *verlet_list;
        FPTYPE *verlet_oldx, verlet_maxdx;
        int *verlet_nrpairs;
        int verlet_size, verlet_next;
        pthread_mutex_t verlet_force_mutex;

        int nr_pairs;

        struct cellpair *pairs;

        int next_pair;

        struct celltuple *tuples;

        int nr_tuples;

        int next_tuple, next_cell;

        pthread_mutex_t cellpairs_mutex;

        //lock_type cellpairs_spinlock;

        pthread_cond_t cellpairs_avail;
 
    } space;
 
 
    /* associated functions */

    CAPI_FUNC(HRESULT) space_init(
        struct space *s, 
        const FPTYPE *origin,
        const FPTYPE *dim, 
        FPTYPE *L, 
        FPTYPE cutoff, 
        const struct BoundaryConditions *bc
    );

    CAPI_FUNC(int) space_getsid(
        struct space *s, 
        struct space_cell **ci,
        struct space_cell **cj, 
        FPTYPE *shift
    );

    CAPI_FUNC(HRESULT) space_shuffle(struct space *s);

    CAPI_FUNC(HRESULT) space_shuffle_local(struct space *s);

    CAPI_FUNC(HRESULT) space_growparts(struct space *s, unsigned int size_incr);

    CAPI_FUNC(HRESULT) space_addpart(
        struct space *s, 
        struct Particle *p,
        FPTYPE *x, 
        struct Particle **result
    );
 
    CAPI_FUNC(HRESULT) space_addparts(
        struct space *s, 
        int nr_parts, 
        struct Particle **parts, 
        FPTYPE **xparts
    );

    CAPI_FUNC(int) space_get_cellids_for_pos(struct space *s, FPTYPE *x, int *cellids);

    CAPI_FUNC(HRESULT) space_del_particle(struct space *s,  int pid);
 

    CAPI_FUNC(HRESULT) space_update_style(struct space *s);

    CAPI_FUNC(HRESULT) space_prepare_tasks(struct space *s);

    CAPI_FUNC(HRESULT) space_prepare(struct space *s);

    CAPI_FUNC(HRESULT) space_getpos(struct space *s, int id, FPTYPE *x);

    CAPI_FUNC(HRESULT) space_setpos(struct space *s, int id, FPTYPE *x);

    CAPI_FUNC(HRESULT) space_flush(struct space *s);

    CAPI_FUNC(HRESULT) space_flush_ghosts(struct space *s);

    CAPI_FUNC(struct task*) space_addtask(
        struct space *s, 
        int type,
        int subtype, 
        int flags, 
        int i, 
        int j
    );

    CAPI_FUNC(HRESULT) space_verlet_init(struct space *s, int list_global);

    CAPI_FUNC(int) space_gettuple(struct space *s, struct celltuple **out, int wait);

    CAPI_FUNC(int) space_getcell(struct space *s, struct space_cell **out);

    CAPI_FUNC(int) space_verlet_force(struct space *s, FPTYPE *f, FPTYPE epot);

    CAPI_FUNC(HRESULT) space_releasepair(struct space *s, int ci, int cj);
 
};
 
#endif // _MDCORE_INCLUDE_TFSPACE_H_