trackers.hpp

Go to the documentation of this file.

#include "box.hpp"

#ifndef TRACKERS_H
#define TRACKERS_H

#include <set>
#include <map>
#include "assert.h"

class StateTracker {
    public:
        virtual void update(Box &box) = 0;
        virtual ~StateTracker(){};
};

class PairList {
    protected:
        map<const AtomID, set<AtomID> > pairs;
    public:
        //~ PairList(AtomGroup *group);
        PairList(){};

        inline void ensure(const AtomID a){
            pairs.insert(std::pair<AtomID, set<AtomID> >(a, set<AtomID>()));
        }
        inline void ensure(vector<AtomID> ps){
            vector<AtomID>::iterator it;
            for(it=ps.begin(); it != ps.end(); ++it) ensure(*it);
        }
        inline void ensure(AtomGroup &group){
            for(uint i=0; i<group.size(); i++) ensure(group.get_id(i));
        }
        inline bool has_pair(AtomID a1, AtomID a2){
            if(a1 > a2) return pairs[a1].count(a2) > 0;
            else return pairs[a2].count(a1) > 0;
        }

        inline void add_pair(AtomID a1, AtomID a2){
            //~ cout << "PairList ignore " << a1.n() << '-' << a2.n() << "\n";
            if(a1 > a2){pairs[a1].insert(a2);}
            else{pairs[a2].insert(a1);};
        }


        inline void erase_pair(AtomID a1, AtomID a2){
            if(a1 > a2){pairs[a1].erase(a2);}
            else{pairs[a2].erase(a1);};
        }

        inline set<AtomID> get_pairs(const AtomID a){ensure(a); return pairs[a];};

        inline set<AtomID>::iterator begin(const AtomID a){return pairs[a].begin();};
        inline set<AtomID>::iterator end(const AtomID a){return pairs[a].end();};

        inline uint size() const { uint N=0; for(
            map<const AtomID, set<AtomID> >::const_iterator it=pairs.begin();
            it != pairs.end(); ++it) N+= (uint) it->second.size();
            return N;
        };

        void clear();
};

class NeighborList : public StateTracker{
    protected:
        sptr<Box> box;
        flt skin;
        SubGroup atoms;
        vector<flt> diameters;
        vector<IDPair> curpairs;
        PairList ignorepairs;
        vector<Vec> lastlocs;
        uint updatenum;
        bool ignorechanged; /*< if true, forces a full check on next update */
    public:
        NeighborList(sptr<Box> box, sptr<AtomVec> atoms, const flt skin);
        void update(Box &newbox){assert(&newbox == box.get()); update_list(false);};
        bool update_list(bool force = true);
        // if force = false, we check if updating necessary first

        AtomVec& vec(){return atoms.vec();};
        inline uint which(){return updatenum;};
        inline uint numpairs(){return (uint) curpairs.size();};
        inline void ignore(AtomID a, AtomID b){ignorepairs.add_pair(a,b); ignorechanged=true;};
        void add(AtomID a, flt diameter){
            atoms.add(a);
            //assert(diameters.size() == atoms.size() - 1);
            diameters.push_back(diameter);
            //assert(lastlocs.size() == atoms.size() - 1);
            lastlocs.push_back(a->x);
            ignorechanged = true;
        }

        inline uint ignore_size() const{return ignorepairs.size();};
        inline uint size() const{return atoms.size();};
        inline vector<IDPair>::iterator begin(){return curpairs.begin();};
        inline vector<IDPair>::iterator end(){return curpairs.end();};
        inline IDPair get(uint i){
            //assert(i<curpairs.size());
            return curpairs[i];
        };
        ~NeighborList(){};
};

class GridIterator;
class GridPairedIterator;

class Grid {
    public:
        sptr<OriginBox> box;
        sptr<AtomGroup> atoms;

        flt minwidth;
        flt goalwidth; 
        uint widths[NDIM]; 
        vector<set<AtomID> > gridlocs; 
        vector<uint> neighbors(uint i);
        uint get_loc(Vec v, Vec bsize);

    public:
        typedef GridIterator iterator;
        typedef GridPairedIterator pair_iter;

        Grid(sptr<OriginBox> box, sptr<AtomGroup> atoms, const uint width=1);

        Grid(sptr<OriginBox> box, sptr<AtomGroup> atoms, vector<uint> width);

        Grid(sptr<OriginBox> box, sptr<AtomGroup> atoms, const flt minwidth, const flt goalwidth);

        void optimize_widths();
        void make_grid();

        friend class GridIterator;
        friend class GridPairedIterator;
        iterator begin();
        iterator end();

        pair_iter pairs(AtomID a);
        flt time_to_edge(Atom& a);
        flt time_to_edge(uint i){return time_to_edge((*atoms)[i]);}

        vector<IDPair> all_pairs();
        vector<AtomID> all_pairs(AtomID a);

        uint numcells(uint i){assert(i<NDIM); return widths[i];}
        #ifdef VEC2D
        uint numcells(){ return widths[0] * widths[1];};
        #else
        uint numcells(){ return widths[0] * widths[1] * widths[2];};
        #endif
};

class GridPairedIterator {
    protected:
        Grid & grid;
        AtomID atom1;

        vector<uint> neighbor_cells;
        vector<uint>::iterator cellnum2;
        set<AtomID> *cell2;
        set<AtomID>::iterator atom2;

        bool increment_cell2();
        bool increment_atom2();

    public:
        typedef set<AtomID>::iterator end_type;

        GridPairedIterator(Grid & grid, AtomID a);

        GridPairedIterator& operator++();
        AtomID operator*(){return *atom2;};
        bool operator==(const GridPairedIterator &other);

        bool operator!=(const GridPairedIterator &other){
            return !(*this == other);
        };

        bool operator==(const end_type other){
            return (atom2 == other);
        }
        bool operator!=(const end_type other){
            return !(atom2 == other);
        };

        end_type end(){return grid.gridlocs[neighbor_cells.back()].end();};
};

class GridIterator {
    protected:
        Grid & grid;
        vector<set<AtomID> >::iterator cell1;
        set<AtomID>::iterator atom1;

        vector<uint> neighbor_cells;
        vector<uint>::iterator cellnum2;
        set<AtomID> *cell2;
        set<AtomID>::iterator atom2;

        // returns "successful increment", e.g. cell1 points to an element
        bool increment_cell1();
        bool increment_atom1();
        bool increment_cell2();
        bool increment_atom2();

    public:
        GridIterator(Grid & grid);
        GridIterator(Grid & grid, vector<set<AtomID> >::iterator cell1);

        GridIterator& operator++();
        IDPair operator*(){return IDPair(*atom1, *atom2);};
        bool operator==(const GridIterator &other);

        bool operator!=(const GridIterator &other){
            return !(*this == other);
        };
};

#endif