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 246 by gezelter, Wed Jan 12 22:41:40 2005 UTC vs.
Revision 1953 by gezelter, Thu Dec 5 18:19:26 2013 UTC

#	Line 1 | Line 1
1	<	/*
1	>	/*
2		* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3		*
4		* The University of Notre Dame grants you ("Licensee") a
#	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
62	<	* @brief
63	<	* @todo documentation
64	<	*/
65	<	class IndexListContainer{
66	<	public:
67	<	static const int MAX_INTEGER = 2147483647;
68	<	typedef std::list<std::pair<int, int> >::iterator  IndexListContainerIterator;
60	>	/**
61	>	* @class IndexListContainer
62	>	* @brief
63	>	* @todo documentation
64	>	*/
65	>	class IndexListContainer{
66	>	public:
67	>	static const int MAX_INTEGER = 2147483647;
68	>	typedef std::list<std::pair<int, int> >::iterator IndexListContainerIterator;
69
70	+	IndexListContainer(int minIndex = 0, int maxIndex = MAX_INTEGER)
71	+	:minIndex_(minIndex), maxIndex_(maxIndex) {
72	+	indexContainer_.push_back(std::make_pair(minIndex, maxIndex));
73	+	}
74
75	<	IndexListContainer(int minIndex = 0, int maxIndex = MAX_INTEGER)
76	<	:minIndex_(minIndex), maxIndex_(maxIndex) {
77	<
78	<	indexContainer_.push_back(std::make_pair(minIndex, maxIndex));
74	<	}
75	<
76	<	int pop() {
77	<
78	<	if (indexContainer_.empty()) {
79	<	std::cerr << "" << std::endl;
80	<	}
75	>	int pop() {
76	>	if (indexContainer_.empty()) {
77	>	std::cerr << "" << std::endl;
78	>	}
79
80	<	IndexListContainerIterator i = indexContainer_.begin();
83	<	int result;
80	>	int result;
81
82	<	result = indexContainer_.front().first;
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) {
87	<	++indexContainer_.front().first;
88	<	} else {
89	<	std::cerr << "" << std::endl;
90	<	}
84	>	if (indexContainer_.front().first  == indexContainer_.front().second) {
85	>	indexContainer_.pop_front();
86	>	} else if (indexContainer_.front().first <
87	>	indexContainer_.front().second) {
88	>	++indexContainer_.front().first;
89	>	} else {
90	>	std::cerr << "" << std::endl;
91	>	}
92	>
93	>	return result;
94	>	}
95
95	–	return result;
96	–	}
96
97	+	/**
98	+	*
99	+	*/
100	+	void insert(int index) {
101	+	IndexListContainerIterator insertPos = internalInsert(index, index);
102	+	merge(insertPos);
103	+	}
104
105	<	/**
106	<	*
107	<	*/
108	<	void insert(int index) {
109	<	IndexListContainerIterator insertPos = internalInsert(index, index);
110	<	merge(insertPos);
111	<	}
105	>	/**
106	>	* Reclaims an index range
107	>	* @param beginIndex
108	>	* @param endIndex
109	>	*/
110	>	void insert(int beginIndex, int endIndex) {
111	>	IndexListContainerIterator insertPos = internalInsert(beginIndex,
112	>	endIndex);
113	>	merge(insertPos);
114	>	}
115
116	<	/**
117	<	* Reclaims an index range
118	<	* @param beginIndex
119	<	* @param endIndex
120	<	*/
112	<	void insert(int beginIndex, int endIndex) {
113	<	IndexListContainerIterator insertPos = internalInsert(beginIndex, endIndex);
114	<	merge(insertPos);
115	<	}
116	>	/**
117	>	* Reclaims an index array.
118	>	* @param indices
119	>	*/
120	>	void insert(std::vector<int>& indices){
121
122	<	/**
123	<	* Reclaims an index array.
124	<	* @param indices
120	<	*/
121	<	void insert(std::vector<int>& indices){
122	<
123	<	if (indices.empty()) {
124	<	return;
125	<	}
122	>	if (indices.empty()) {
123	>	return;
124	>	}
125
126	<	std::sort(indices.begin(), indices.end());
127	<	std::unique(indices.begin(), indices.end());
126	>	std::sort(indices.begin(), indices.end());
127	>	std::unique(indices.begin(), indices.end());
128
129	<	std::vector<int>::iterator i;
130	<	IndexListContainerIterator insertPos;
132	<	int beginIndex;
129	>	std::vector<int>::iterator i;
130	>	int beginIndex;
131
132	<	beginIndex = indices[0];
132	>	beginIndex = indices[0];
133
134	<	for ( i = indices.begin() + 1 ; i != indices.end(); ++i) {
135	<	if (*i != *(i -1) + 1) {
136	<	insert(beginIndex, *(i-1));
137	<	beginIndex = *i;
138	<	}
139	<	}
140	<
143	<
144	<	}
134	>	for ( i = indices.begin() + 1 ; i != indices.end(); ++i) {
135	>	if (*i != *(i -1) + 1) {
136	>	insert(beginIndex, *(i-1));
137	>	beginIndex = *i;
138	>	}
139	>	}
140	>	}
141
142	<	std::vector<int> getIndicesBefore(int index) {
143	<	std::vector<int> result;
144	<	IndexListContainerIterator i;
142	>	std::vector<int> getIndicesBefore(int index) {
143	>	std::vector<int> result;
144	>	IndexListContainerIterator i;
145
146	<	for(i = indexContainer_.begin(); i != indexContainer_.end(); ++i) {
147	<	if ((*i).first > index) {
148	<	//we locate the node whose minimum index is greater that index
149	<	indexContainer_.erase(indexContainer_.begin(), i);
150	<	break;
151	<	} else if ((*i).second < index) {
152	<	//The biggest index current node hold is less than the index we want
153	<	for (int j = (*i).first; j <= (*i).second; ++j) {
154	<	result.push_back(j);
155	<	}
156	<	continue;
157	<	} else if ((*i).first == (*i).second) {
158	<	//the index happen to equal to a node which only contains one index
159	<	result.push_back((*i).first);
160	<	indexContainer_.erase(indexContainer_.begin(), i);
161	<	break;
162	<	} else {
163	<
164	<	for (int j = (*i).first; j < index; ++j) {
165	<	result.push_back(j);
166	<	}
167	<
168	<	(*i).first =  index;
169	<	indexContainer_.erase(indexContainer_.begin(), i);
170	<	break;
171	<	}
172	<
177	<	}
178	<
179	<	return result;
180	<
181	<	}
146	>	for(i = indexContainer_.begin(); i != indexContainer_.end(); ++i) {
147	>	if ((*i).first > index) {
148	>	//we locate the node whose minimum index is greater that index
149	>	indexContainer_.erase(indexContainer_.begin(), i);
150	>	break;
151	>	} else if ((*i).second < index) {
152	>	//The biggest index current node hold is less than the index we want
153	>	for (int j = (*i).first; j <= (*i).second; ++j) {
154	>	result.push_back(j);
155	>	}
156	>	continue;
157	>	} else if ((*i).first == (*i).second) {
158	>	//the index happen to equal to a node which only contains one index
159	>	result.push_back((*i).first);
160	>	indexContainer_.erase(indexContainer_.begin(), i);
161	>	break;
162	>	} else {
163	>	for (int j = (*i).first; j < index; ++j) {
164	>	result.push_back(j);
165	>	}
166	>	(*i).first =  index;
167	>	indexContainer_.erase(indexContainer_.begin(), i);
168	>	break;
169	>	}
170	>	}
171	>	return result;
172	>	}
173
174	<	int getMaxIndex() {
175	<	return maxIndex_;
176	<	}
174	>	int getMaxIndex() {
175	>	return maxIndex_;
176	>	}
177
178	<	private:
178	>	private:
179
180	<	IndexListContainerIterator internalInsert(int beginIndex, int endIndex) {
180	>	IndexListContainerIterator internalInsert(int beginIndex, int endIndex) {
181
182	<	if (beginIndex > endIndex) {
183	<	std::swap(beginIndex, endIndex);
184	<	std::cerr << "" << std::endl;
185	<	}
182	>	if (beginIndex > endIndex) {
183	>	std::swap(beginIndex, endIndex);
184	>	std::cerr << "" << std::endl;
185	>	}
186
187	<	if (endIndex > maxIndex_) {
188	<	std::cerr << "" << std::endl;
189	<	}
187	>	if (endIndex > maxIndex_) {
188	>	std::cerr << "" << std::endl;
189	>	}
190	>
191	>	IndexListContainerIterator i = indexContainer_.begin();
192	>	for (; i != indexContainer_.end(); ++i) {
193	>	if ((*i).first > endIndex) {
194	>	indexContainer_.insert(i, std::make_pair(beginIndex, endIndex));
195	>	return --i;
196	>	} else if ((*i).second < beginIndex) {
197	>	continue;
198	>	} else {
199	>	std::cerr << "" << std::endl;
200	>	}
201	>	}
202
203	<
204	<	IndexListContainerIterator j;
203	>	indexContainer_.push_back(std::make_pair(beginIndex, endIndex));
204	>	return --indexContainer_.end();
205
206	<	IndexListContainerIterator i = indexContainer_.begin();
204	<	for (; i != indexContainer_.end(); ++i) {
205	<	if ((*i).first > endIndex) {
206	<	indexContainer_.insert(i, std::make_pair(beginIndex, endIndex));
207	<	return --i;
208	<	} else if ((*i).second < beginIndex) {
209	<	continue;
210	<	} else {
211	<	std::cerr << "" << std::endl;
212	<	}
213	<	}
206	>	}
207
208	<	indexContainer_.push_back(std::make_pair(beginIndex, endIndex));
209	<	return --indexContainer_.end();
208	>	void merge(IndexListContainerIterator i) {
209	>	IndexListContainerIterator j;
210
211	<	}
211	>	//check whether current node can be merged with its previous node
212	>	if ( i != indexContainer_.begin()) {
213	>	j = i;
214	>	--j;
215	>	if (j != indexContainer_.begin() && (*j).second + 1 == (*i).first) {
216	>	(*i).first = (*j).first;
217	>	indexContainer_.erase(j);
218	>	}
219	>	}
220
221	<	void merge(IndexListContainerIterator i) {
222	<	IndexListContainerIterator j;
221	>	//check whether current node can be merged with its next node
222	>	if ( i != indexContainer_.end()) {
223	>	j = i;
224	>	++j;
225
226	<	//check whether current node can be merged with its previous node
227	<	if ( i != indexContainer_.begin()) {
228	<	j = i;
229	<	--j;
230	<	if (j != indexContainer_.begin() && (*j).second + 1 == (*i).first) {
228	<	(*i).first = (*j).first;
229	<	indexContainer_.erase(j);
230	<	}
231	<	}
226	>	if (j != indexContainer_.end() && (*i).second + 1 == (*j).first) {
227	>	(*i).second = (*j).second;
228	>	indexContainer_.erase(j);
229	>	}
230	>	}
231
232	<	//check whether current node can be merged with its next node
233	<	if ( i != indexContainer_.end()) {
234	<	j = i;
235	<	++j;
232	>	}
233	>	int minIndex_;
234	>	int maxIndex_;
235	>	std::list<std::pair<int, int> > indexContainer_;
236	>	};
237
238	–	if (j != indexContainer_.end() && (*i).second + 1 == (*j).first) {
239	–	(*i).second = (*j).second;
240	–	indexContainer_.erase(j);
241	–	}
242	–	}
238
239	<	}
240	<	int minIndex_;
241	<	int maxIndex_;
242	<	std::list<std::pair<int, int> > indexContainer_;
243	<	};
239	>	/**
240	>	* @class LocalIndexManager LocalIndexManager.hpp "utils/LocalIndexManager.hpp"
241	>	* @brief
242	>	*/
243	>	class LocalIndexManager {
244	>	public:
245	>
246	>	int getNextAtomIndex() {
247	>	return atomIndexContainer_.pop();
248	>	}
249
250	+	std::vector<int> getAtomIndicesBefore(int index) {
251	+	return atomIndexContainer_.getIndicesBefore(index);
252	+	}
253	+
254	+	void releaseAtomIndex(int index) {
255	+	atomIndexContainer_.insert(index);
256	+	}
257
258	<	/**
259	<	* @class LocalIndexManager LocalIndexManager.hpp "utils/LocalIndexManager.hpp"
260	<	* @brief
261	<	*/
262	<	class LocalIndexManager {
263	<	public:
258	>	void releaseAtomIndex(int beginIndex, int endIndex) {
259	>	atomIndexContainer_.insert(beginIndex, endIndex);
260	>	}
261	>
262	>	void releaseAtomIndex(std::vector<int> indices) {
263	>	atomIndexContainer_.insert(indices);
264	>	}
265	>
266	>	int getNextRigidBodyIndex() {
267	>	return rigidBodyIndexContainer_.pop();
268	>	}
269	>
270	>	std::vector<int> getRigidBodyIndicesBefore(int index) {
271	>	return rigidBodyIndexContainer_.getIndicesBefore(index);
272	>	}
273
274	<	int getNextAtomIndex() {
275	<	return atomIndexContainer_.pop();
276	<	}
274	>	void releaseRigidBodyIndex(int index) {
275	>	rigidBodyIndexContainer_.insert(index);
276	>	}
277
278	<	std::vector<int> getAtomIndicesBefore(int index) {
279	<	return atomIndexContainer_.getIndicesBefore(index);
280	<	}
278	>	void releaseRigidBodyIndex(int beginIndex, int endIndex) {
279	>	rigidBodyIndexContainer_.insert(beginIndex, endIndex);
280	>	}
281	>
282	>	void releaseRigidBodyIndex(std::vector<int> indices) {
283	>	rigidBodyIndexContainer_.insert(indices);
284	>	}
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 releaseAtomIndex(int index) {
295	<	atomIndexContainer_.insert(index);
296	<	}
294	>	void releaseCutoffGroupIndex(int index) {
295	>	cutoffGroupIndexContainer_.insert(index);
296	>	}
297
298	<	void releaseAtomIndex(int beginIndex, int endIndex) {
299	<	atomIndexContainer_.insert(beginIndex, endIndex);
300	<	}
298	>	void releaseCutoffGroupIndex(int beginIndex, int endIndex) {
299	>	cutoffGroupIndexContainer_.insert(beginIndex, endIndex);
300	>	}
301
302	<	void releaseAtomIndex(std::vector<int> indices) {
303	<	atomIndexContainer_.insert(indices);
304	<	}
302	>	void releaseCutoffGroupIndex(std::vector<int> indices) {
303	>	cutoffGroupIndexContainer_.insert(indices);
304	>	}
305	>
306	>	int getNextBondIndex() {
307	>	return bondIndexContainer_.pop();
308	>	}
309
310	<	int getNextRigidBodyIndex() {
311	<	return rigidBodyIndexContainer_.pop();
312	<	}
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	<	std::vector<int> getRigidBodyIndicesBefore(int index) {
319	<	return rigidBodyIndexContainer_.getIndicesBefore(index);
320	<	}
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 releaseRigidBodyIndex(int index) {
335	<	rigidBodyIndexContainer_.insert(index);
336	<	}
334	>	void releaseBendIndex(int index) {
335	>	bendIndexContainer_.insert(index);
336	>	}
337
338	<	void releaseRigidBodyIndex(int beginIndex, int endIndex) {
339	<	rigidBodyIndexContainer_.insert(beginIndex, endIndex);
340	<	}
338	>	void releaseBendIndex(int beginIndex, int endIndex) {
339	>	bendIndexContainer_.insert(beginIndex, endIndex);
340	>	}
341
342	<	void releaseRigidBodyIndex(std::vector<int> indices) {
343	<	rigidBodyIndexContainer_.insert(indices);
344	<	}
297	<
298	<	private:
342	>	void releaseBendIndex(std::vector<int> indices) {
343	>	bendIndexContainer_.insert(indices);
344	>	}
345
346	<	IndexListContainer atomIndexContainer_;
347	<	IndexListContainer rigidBodyIndexContainer_;
348	<	};
346	>	int getNextTorsionIndex() {
347	>	return torsionIndexContainer_.pop();
348	>	}
349
350	<	} //end namespace oopse
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 OpenMD
398		#endif //UTILS_LOCALINDEXMANAGER_HPP

Comparing trunk/src/utils/LocalIndexManager.hpp (property svn:keywords):
Revision 246 by gezelter, Wed Jan 12 22:41:40 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