ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/trunk/src/utils/LocalIndexManager.hpp

Comparing trunk/src/utils/LocalIndexManager.hpp (file contents):
Revision 507 by gezelter, Fri Apr 15 22:04:00 2005 UTC vs.
Revision 1953 by gezelter, Thu Dec 5 18:19:26 2013 UTC

#	Line 6 | Line 6
6		* redistribute this software in source and binary code form, provided
7		* that the following conditions are met:
8		*
9	<	* 1. Acknowledgement of the program authors must be made in any
10	<	*    publication of scientific results based in part on use of the
11	<	*    program.  An acceptable form of acknowledgement is citation of
12	<	*    the article in which the program was described (Matthew
13	<	*    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14	<	*    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15	<	*    Parallel Simulation Engine for Molecular Dynamics,"
16	<	*    J. Comput. Chem. 26, pp. 252-271 (2005))
17	<	*
18	<	* 2. Redistributions of source code must retain the above copyright
9	>	* 1. Redistributions of source code must retain the above copyright
10		*    notice, this list of conditions and the following disclaimer.
11		*
12	<	* 3. Redistributions in binary form must reproduce the above copyright
12	>	* 2. Redistributions in binary form must reproduce the above copyright
13		*    notice, this list of conditions and the following disclaimer in the
14		*    documentation and/or other materials provided with the
15		*    distribution.
#	Line 37 | Line 28
28		* arising out of the use of or inability to use software, even if the
29		* University of Notre Dame has been advised of the possibility of
30		* such damages.
31	+	*
32	+	* SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33	+	* research, please cite the appropriate papers when you publish your
34	+	* work.  Good starting points are:
35	+	*
36	+	* [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37	+	* [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38	+	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).
39	+	* [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	+	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41		*/
42
43		/**
#	Line 54 | Line 55
55		#include <list>
56		#include <utility>
57
58	<	namespace oopse {
58	>	namespace OpenMD {
59
60		/**
61		* @class IndexListContainer
#	Line 64 | Line 65 | namespace oopse {
65		class IndexListContainer{
66		public:
67		static const int MAX_INTEGER = 2147483647;
68	<	typedef std::list<std::pair<int, int> >::iterator  IndexListContainerIterator;
68	>	typedef std::list<std::pair<int, int> >::iterator IndexListContainerIterator;
69
69	–
70		IndexListContainer(int minIndex = 0, int maxIndex = MAX_INTEGER)
71		:minIndex_(minIndex), maxIndex_(maxIndex) {
72	<
73	<	indexContainer_.push_back(std::make_pair(minIndex, maxIndex));
74	<	}
72	>	indexContainer_.push_back(std::make_pair(minIndex, maxIndex));
73	>	}
74
75	<	int pop() {
77	<
75	>	int pop() {
76		if (indexContainer_.empty()) {
77		std::cerr << "" << std::endl;
78		}
79
82	–	IndexListContainerIterator i = indexContainer_.begin();
80		int result;
81
82		result = indexContainer_.front().first;
83
84		if (indexContainer_.front().first  == indexContainer_.front().second) {
85		indexContainer_.pop_front();
86	<	} else if (indexContainer_.front().first < indexContainer_.front().second) {
86	>	} else if (indexContainer_.front().first <
87	>	indexContainer_.front().second) {
88		++indexContainer_.front().first;
89		} else {
90		std::cerr << "" << std::endl;
91		}
92	<
92	>
93		return result;
94		}
95
#	Line 100 | Line 98 | namespace oopse {
98		*
99		*/
100		void insert(int index) {
101	<	IndexListContainerIterator insertPos = internalInsert(index, index);
101	>	IndexListContainerIterator insertPos = internalInsert(index, index);
102		merge(insertPos);
103		}
104
#	Line 110 | Line 108 | namespace oopse {
108		* @param endIndex
109		*/
110		void insert(int beginIndex, int endIndex) {
111	<	IndexListContainerIterator insertPos = internalInsert(beginIndex, endIndex);
111	>	IndexListContainerIterator insertPos = internalInsert(beginIndex,
112	>	endIndex);
113		merge(insertPos);
114		}
115
#	Line 128 | Line 127 | namespace oopse {
127		std::unique(indices.begin(), indices.end());
128
129		std::vector<int>::iterator i;
131	–	IndexListContainerIterator insertPos;
130		int beginIndex;
131
132		beginIndex = indices[0];
#	Line 139 | Line 137 | namespace oopse {
137		beginIndex = *i;
138		}
139		}
142	–
143	–
140		}
141
142		std::vector<int> getIndicesBefore(int index) {
#	Line 164 | Line 160 | namespace oopse {
160		indexContainer_.erase(indexContainer_.begin(), i);
161		break;
162		} else {
167	–
163		for (int j = (*i).first; j < index; ++j) {
164		result.push_back(j);
165	<	}
171	<
165	>	}
166		(*i).first =  index;
167		indexContainer_.erase(indexContainer_.begin(), i);
168		break;
169		}
176	–
170		}
178	–
171		return result;
180	–
172		}
173
174		int getMaxIndex() {
#	Line 196 | Line 187 | namespace oopse {
187		if (endIndex > maxIndex_) {
188		std::cerr << "" << std::endl;
189		}
190	<
200	<
201	<	IndexListContainerIterator j;
202	<
190	>
191		IndexListContainerIterator i = indexContainer_.begin();
192		for (; i != indexContainer_.end(); ++i) {
193		if ((*i).first > endIndex) {
#	Line 294 | Line 282 | namespace oopse {
282		void releaseRigidBodyIndex(std::vector<int> indices) {
283		rigidBodyIndexContainer_.insert(indices);
284		}
285	<
285	>
286	>	int getNextCutoffGroupIndex() {
287	>	return cutoffGroupIndexContainer_.pop();
288	>	}
289	>
290	>	std::vector<int> getCutoffGroupIndicesBefore(int index) {
291	>	return cutoffGroupIndexContainer_.getIndicesBefore(index);
292	>	}
293	>
294	>	void releaseCutoffGroupIndex(int index) {
295	>	cutoffGroupIndexContainer_.insert(index);
296	>	}
297	>
298	>	void releaseCutoffGroupIndex(int beginIndex, int endIndex) {
299	>	cutoffGroupIndexContainer_.insert(beginIndex, endIndex);
300	>	}
301	>
302	>	void releaseCutoffGroupIndex(std::vector<int> indices) {
303	>	cutoffGroupIndexContainer_.insert(indices);
304	>	}
305	>
306	>	int getNextBondIndex() {
307	>	return bondIndexContainer_.pop();
308	>	}
309	>
310	>	std::vector<int> getBondIndicesBefore(int index) {
311	>	return bondIndexContainer_.getIndicesBefore(index);
312	>	}
313	>
314	>	void releaseBondIndex(int index) {
315	>	bondIndexContainer_.insert(index);
316	>	}
317	>
318	>	void releaseBondIndex(int beginIndex, int endIndex) {
319	>	bondIndexContainer_.insert(beginIndex, endIndex);
320	>	}
321	>
322	>	void releaseBondIndex(std::vector<int> indices) {
323	>	bondIndexContainer_.insert(indices);
324	>	}
325	>
326	>	int getNextBendIndex() {
327	>	return bendIndexContainer_.pop();
328	>	}
329	>
330	>	std::vector<int> getBendIndicesBefore(int index) {
331	>	return bendIndexContainer_.getIndicesBefore(index);
332	>	}
333	>
334	>	void releaseBendIndex(int index) {
335	>	bendIndexContainer_.insert(index);
336	>	}
337	>
338	>	void releaseBendIndex(int beginIndex, int endIndex) {
339	>	bendIndexContainer_.insert(beginIndex, endIndex);
340	>	}
341	>
342	>	void releaseBendIndex(std::vector<int> indices) {
343	>	bendIndexContainer_.insert(indices);
344	>	}
345	>
346	>	int getNextTorsionIndex() {
347	>	return torsionIndexContainer_.pop();
348	>	}
349	>
350	>	std::vector<int> getTorsionIndicesBefore(int index) {
351	>	return torsionIndexContainer_.getIndicesBefore(index);
352	>	}
353	>
354	>	void releaseTorsionIndex(int index) {
355	>	torsionIndexContainer_.insert(index);
356	>	}
357	>
358	>	void releaseTorsionIndex(int beginIndex, int endIndex) {
359	>	torsionIndexContainer_.insert(beginIndex, endIndex);
360	>	}
361	>
362	>	void releaseTorsionIndex(std::vector<int> indices) {
363	>	torsionIndexContainer_.insert(indices);
364	>	}
365	>
366	>	int getNextInversionIndex() {
367	>	return inversionIndexContainer_.pop();
368	>	}
369	>
370	>	std::vector<int> getInversionIndicesBefore(int index) {
371	>	return inversionIndexContainer_.getIndicesBefore(index);
372	>	}
373	>
374	>	void releaseInversionIndex(int index) {
375	>	inversionIndexContainer_.insert(index);
376	>	}
377	>
378	>	void releaseInversionIndex(int beginIndex, int endIndex) {
379	>	inversionIndexContainer_.insert(beginIndex, endIndex);
380	>	}
381	>
382	>	void releaseInversionIndex(std::vector<int> indices) {
383	>	inversionIndexContainer_.insert(indices);
384	>	}
385	>
386		private:
387
388		IndexListContainer atomIndexContainer_;
389		IndexListContainer rigidBodyIndexContainer_;
390	+	IndexListContainer cutoffGroupIndexContainer_;
391	+	IndexListContainer bondIndexContainer_;
392	+	IndexListContainer bendIndexContainer_;
393	+	IndexListContainer torsionIndexContainer_;
394	+	IndexListContainer inversionIndexContainer_;
395		};
396
397	<	} //end namespace oopse
397	>	} //end namespace OpenMD
398		#endif //UTILS_LOCALINDEXMANAGER_HPP

Comparing trunk/src/utils/LocalIndexManager.hpp (property svn:keywords):
Revision 507 by gezelter, Fri Apr 15 22:04:00 2005 UTC vs.
Revision 1953 by gezelter, Thu Dec 5 18:19:26 2013 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

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