ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/devel_omp/src/primitives/CutoffGroup.hpp
(Generate patch)

Comparing branches/devel_omp/src/primitives/CutoffGroup.hpp (file contents):
Revision 1594 by chuckv, Tue Jul 19 16:45:30 2011 UTC vs.
Revision 1598 by mciznick, Wed Jul 27 14:26:53 2011 UTC

# Line 38 | Line 38
38   * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39   * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41 <
41 >
42   #ifndef PRIMITIVES_CUTOFFGROUP_HPP
43  
44   #define PRIMITIVES_CUTOFFGROUP_HPP
# Line 47 | Line 47 | namespace OpenMD {
47   #include "math/Vector3.hpp"
48  
49   namespace OpenMD {
50 <  class CutoffGroup {
51 <  public:
52 <    
53 <    CutoffGroup() :  snapshotMan_(NULL) {
50 > class CutoffGroup {
51 > public:
52  
53 <      storage_ = &Snapshot::cgData;
54 <      haveTotalMass = false;
57 <      totalMass = 0.0;
58 <    }
59 <    
60 <    /**
61 <     * Sets the Snapshot Manager of this cutoffGroup
62 <     */
63 <    void setSnapshotManager(SnapshotManager* sman) {
64 <      snapshotMan_ = sman;
65 <    }
53 >        CutoffGroup() :
54 >                snapshotMan_(NULL) {
55  
56 +                storage_ = &Snapshot::cgData;
57 +                haveTotalMass = false;
58 +                totalMass = 0.0;
59 +        }
60  
61 <    void addAtom(Atom *atom) {
62 <      cutoffAtomList.push_back(atom);
63 <    }
64 <    
65 <    Atom *beginAtom(std::vector<Atom *>::iterator & i) {
66 <      i = cutoffAtomList.begin();
74 <      return i != cutoffAtomList.end() ? *i : NULL;
75 <    }
76 <    
77 <    Atom *nextAtom(std::vector<Atom *>::iterator & i) {
78 <      i++;
79 <      return i != cutoffAtomList.end() ? *i : NULL;
80 <    }
61 >        /**
62 >         * Sets the Snapshot Manager of this cutoffGroup
63 >         */
64 >        void setSnapshotManager(SnapshotManager* sman) {
65 >                snapshotMan_ = sman;
66 >        }
67  
68 <    std::vector<Atom*> getAtoms() { return cutoffAtomList; }
69 <    RealType getMass() {
84 <      std::vector<Atom *>::iterator i;
85 <      Atom * atom;
86 <      RealType mass;
87 <      
88 <      if (!haveTotalMass) {
89 <        totalMass = 0;
90 <        
91 <        for(atom = beginAtom(i); atom != NULL; atom = nextAtom(i)) {
92 <          mass = atom->getMass();
93 <          totalMass += mass;
68 >        void addAtom(Atom *atom) {
69 >                cutoffAtomList.push_back(atom);
70          }
95 –        
96 –        haveTotalMass = true;
97 –      }
98 –      
99 –      return totalMass;
100 –    }
101 –    
102 –    void updateCOM() {
103 –      std::vector<Atom *>::iterator i;
104 –      Atom * atom;
71  
72 <      DataStorage&  data = snapshotMan_->getCurrentSnapshot()->*storage_;
73 <    
74 <      totalMass = getMass();
75 <      
110 <      if (cutoffAtomList.size() == 1) {
111 <        data.position[localIndex_] = beginAtom(i)->getPos();
112 <      } else {
113 <        data.position[localIndex_] = V3Zero;
114 <        for(atom = beginAtom(i); atom != NULL; atom = nextAtom(i)) {
115 <          data.position[localIndex_] += atom->getMass() * atom->getPos();
116 <        }        
117 <        data.position[localIndex_] /= totalMass;
118 <      }
119 <    }
72 >        Atom *beginAtom(std::vector<Atom *>::iterator & i) {
73 >                i = cutoffAtomList.begin();
74 >                return i != cutoffAtomList.end() ? *i : NULL;
75 >        }
76  
77 +        Atom *nextAtom(std::vector<Atom *>::iterator & i) {
78 +                i++;
79 +                return i != cutoffAtomList.end() ? *i : NULL;
80 +        }
81  
82 <    Vector3d getPos() {
83 <      return ((snapshotMan_->getCurrentSnapshot())->*storage_).position[localIndex_];      
84 <    }
85 <    
86 <    int getNumAtom() {
87 <      return cutoffAtomList.size();
88 <    }
129 <    
130 <    int getGlobalIndex() {
131 <      return globalIndex;
132 <    }
133 <    
134 <    void setGlobalIndex(int id) {
135 <      this->globalIndex = id;
136 <    }
82 >        std::vector<Atom*> getAtoms() {
83 >                return cutoffAtomList;
84 >        }
85 >        RealType getMass() {
86 >                std::vector<Atom *>::iterator i;
87 >                Atom * atom;
88 >                RealType mass;
89  
90 <    /**
91 <     * Returns the local index of this cutoffGroup
92 <     * @return the local index of this cutoffGroup
141 <     */
142 <    int getLocalIndex() {
143 <      return localIndex_;
144 <    }
90 >                if (!haveTotalMass)
91 >                {
92 >                        totalMass = 0;
93  
94 <    /**
95 <     * Sets the local index of this cutoffGroup
96 <     * @param index new index to be set
97 <     */        
98 <    void setLocalIndex(int index) {
151 <      localIndex_ = index;
152 <    }
153 <    
154 <  private:
155 <    
156 <    std::vector<Atom *>cutoffAtomList;
157 <    bool haveTotalMass;
158 <    RealType totalMass;
159 <    int globalIndex;    
94 >                        for (atom = beginAtom(i); atom != NULL; atom = nextAtom(i))
95 >                        {
96 >                                mass = atom->getMass();
97 >                                totalMass += mass;
98 >                        }
99  
100 <    int localIndex_;
101 <    DataStoragePointer storage_;
163 <    SnapshotManager* snapshotMan_;
100 >                        haveTotalMass = true;
101 >                }
102  
103 <  };  
103 >                return totalMass;
104 >        }
105 >
106 >        void updateCOM() {
107 >                std::vector<Atom *>::iterator i;
108 >                Atom * atom;
109 >
110 >                DataStorage& data = snapshotMan_->getCurrentSnapshot()->*storage_;
111 >
112 >                totalMass = getMass();
113 >
114 >                if (cutoffAtomList.size() == 1)
115 >                {
116 >                        data.position[localIndex_] = beginAtom(i)->getPos();
117 >                } else
118 >                {
119 >                        data.position[localIndex_] = V3Zero;
120 >                        for (atom = beginAtom(i); atom != NULL; atom = nextAtom(i))
121 >                        {
122 >                                data.position[localIndex_] += atom->getMass() * atom->getPos();
123 >                        }
124 >                        data.position[localIndex_] /= totalMass;
125 >                }
126 >        }
127 >
128 >        Vector3d getPos() {
129 >                return ((snapshotMan_->getCurrentSnapshot())->*storage_).position[localIndex_];
130 >        }
131 >
132 >        int getNumAtom() {
133 >                return cutoffAtomList.size();
134 >        }
135 >
136 >        int getGlobalIndex() {
137 >                return globalIndex;
138 >        }
139 >
140 >        void setGlobalIndex(int id) {
141 >                this->globalIndex = id;
142 >        }
143 >
144 >        /**
145 >         * Returns the local index of this cutoffGroup
146 >         * @return the local index of this cutoffGroup
147 >         */
148 >        int getLocalIndex() {
149 >                return localIndex_;
150 >        }
151 >
152 >        /**
153 >         * Sets the local index of this cutoffGroup
154 >         * @param index new index to be set
155 >         */
156 >        void setLocalIndex(int index) {
157 >                localIndex_ = index;
158 >        }
159 >
160 > private:
161 >
162 >        std::vector<Atom *> cutoffAtomList;
163 >        bool haveTotalMass;
164 >        RealType totalMass;
165 >        int globalIndex;
166 >
167 >        int localIndex_;
168 >        DataStoragePointer storage_;
169 >        SnapshotManager* snapshotMan_;
170 >
171 > };
172   } //end namespace OpenMD
173   #endif //PRIMITIVES_CUTOFFGROUP_HPP  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines