src/utils/LocalIndexManager.hpp

/*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 *
 * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
 * research, please cite the appropriate papers when you publish your
 * work.  Good starting points are:
 *                                                                      
 * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
 * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
 * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
 * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
 */
 
/**
 * @file LocalIndexManager.hpp
 * @author    tlin
 * @date  11/02/2004
 * @version 1.0
 */ 

#ifndef UTILS_LOCALINDEXMANAGER_HPP
#define UTILS_LOCALINDEXMANAGER_HPP
#include <algorithm>
#include <iostream>
#include <cassert>
#include <list>
#include <utility>

namespace OpenMD {

  /**
   * @class IndexListContainer
   * @brief 
   * @todo documentation
   */
  class IndexListContainer{
  public:
    static const int MAX_INTEGER = 2147483647;
    typedef std::list<std::pair<int, int> >::iterator  IndexListContainerIterator;

        
    IndexListContainer(int minIndex = 0, int maxIndex = MAX_INTEGER) 
      :minIndex_(minIndex), maxIndex_(maxIndex) {
            
        indexContainer_.push_back(std::make_pair(minIndex, maxIndex));
      }
        
    int pop() {
            
      if (indexContainer_.empty()) {
        std::cerr << "" << std::endl;
      }

      IndexListContainerIterator i = indexContainer_.begin();
      int result;
            
      result = indexContainer_.front().first;
            
      if (indexContainer_.front().first  == indexContainer_.front().second) {
        indexContainer_.pop_front();
      } else if (indexContainer_.front().first < indexContainer_.front().second) {
        ++indexContainer_.front().first;
      } else {
        std::cerr << "" << std::endl;
      }

      return result;
    }


    /**
     *
     */
    void insert(int index) {
      IndexListContainerIterator insertPos = internalInsert(index, index);            
      merge(insertPos);
    }

    /**
     * Reclaims an index range
     * @param beginIndex
     * @param endIndex
     */
    void insert(int beginIndex, int endIndex) {
      IndexListContainerIterator insertPos = internalInsert(beginIndex, endIndex); 
      merge(insertPos);            
    }

    /**
     * Reclaims an index array.
     * @param indices
     */
    void insert(std::vector<int>& indices){

      if (indices.empty()) {
        return;
      }
            
      std::sort(indices.begin(), indices.end());
      std::unique(indices.begin(), indices.end());

      std::vector<int>::iterator i;
      IndexListContainerIterator insertPos;
      int beginIndex;

      beginIndex = indices[0];
        
      for ( i = indices.begin() + 1 ; i != indices.end(); ++i) {
        if (*i != *(i -1) + 1) {
          insert(beginIndex, *(i-1));
          beginIndex = *i;
        }
      }
            
            
    }
        
    std::vector<int> getIndicesBefore(int index) {
      std::vector<int> result;
      IndexListContainerIterator i;

      for(i = indexContainer_.begin(); i != indexContainer_.end(); ++i) {
        if ((*i).first > index) {
          //we locate the node whose minimum index is greater that index
          indexContainer_.erase(indexContainer_.begin(), i);
          break;
        } else if ((*i).second < index) {
          //The biggest index current node hold is less than the index we want
          for (int j = (*i).first; j <= (*i).second; ++j) {
            result.push_back(j);
          }
          continue;
        } else if ((*i).first == (*i).second) {
          //the index happen to equal to a node which only contains one index
          result.push_back((*i).first);
          indexContainer_.erase(indexContainer_.begin(), i);
          break;
        } else {

          for (int j = (*i).first; j < index; ++j) {
            result.push_back(j);
          }
                        
          (*i).first =  index;                   
          indexContainer_.erase(indexContainer_.begin(), i);
          break;
        }
                
      }

      return result;

    }
        
    int getMaxIndex() {
      return maxIndex_;
    }
                
  private:
        
    IndexListContainerIterator internalInsert(int beginIndex, int endIndex) {

      if (beginIndex > endIndex) {
        std::swap(beginIndex, endIndex);
        std::cerr << "" << std::endl;
      }

      if (endIndex > maxIndex_) {
        std::cerr << "" << std::endl;
      }

                      
      IndexListContainerIterator j;

      IndexListContainerIterator i = indexContainer_.begin();  
      for (; i != indexContainer_.end(); ++i) {
        if ((*i).first > endIndex) {
          indexContainer_.insert(i, std::make_pair(beginIndex, endIndex));
          return --i;
        } else if ((*i).second < beginIndex) {
          continue;
        } else {
          std::cerr << "" << std::endl;
        }
      }

      indexContainer_.push_back(std::make_pair(beginIndex, endIndex));
      return --indexContainer_.end();

    }

    void merge(IndexListContainerIterator i) {
      IndexListContainerIterator j;

      //check whether current node can be merged with its previous node            
      if ( i != indexContainer_.begin()) {
        j = i;
        --j;
        if (j != indexContainer_.begin() && (*j).second + 1 == (*i).first) {
          (*i).first = (*j).first;
          indexContainer_.erase(j);
        }
      }

      //check whether current node can be merged with its next node            
      if ( i != indexContainer_.end()) {
        j = i;
        ++j;

        if (j != indexContainer_.end() && (*i).second + 1 == (*j).first) {
          (*i).second = (*j).second;
          indexContainer_.erase(j);
        }
      }

    }
    int minIndex_;
    int maxIndex_;        
    std::list<std::pair<int, int> > indexContainer_;
  };


  /**
   * @class LocalIndexManager LocalIndexManager.hpp "utils/LocalIndexManager.hpp"
   * @brief
   */
  class LocalIndexManager {
  public:
        
    int getNextAtomIndex() {
      return atomIndexContainer_.pop();
    }

    std::vector<int> getAtomIndicesBefore(int index) {
      return atomIndexContainer_.getIndicesBefore(index);
    }
        
    void releaseAtomIndex(int index) {
      atomIndexContainer_.insert(index);
    }

    void releaseAtomIndex(int beginIndex, int endIndex) {
      atomIndexContainer_.insert(beginIndex, endIndex);
    }

    void releaseAtomIndex(std::vector<int> indices) {
      atomIndexContainer_.insert(indices);
    }

    int getNextRigidBodyIndex() {
      return rigidBodyIndexContainer_.pop();
    }

    std::vector<int> getRigidBodyIndicesBefore(int index) {
      return rigidBodyIndexContainer_.getIndicesBefore(index);
    }
        
    void releaseRigidBodyIndex(int index) {
      rigidBodyIndexContainer_.insert(index);
    }

    void releaseRigidBodyIndex(int beginIndex, int endIndex) {
      rigidBodyIndexContainer_.insert(beginIndex, endIndex);
    }

    void releaseRigidBodyIndex(std::vector<int> indices) {
      rigidBodyIndexContainer_.insert(indices);
    }

    int getNextCutoffGroupIndex() {
      return cutoffGroupIndexContainer_.pop();
    }

    std::vector<int> getCutoffGroupIndicesBefore(int index) {
      return cutoffGroupIndexContainer_.getIndicesBefore(index);
    }
        
    void releaseCutoffGroupIndex(int index) {
      cutoffGroupIndexContainer_.insert(index);
    }

    void releaseCutoffGroupIndex(int beginIndex, int endIndex) {
      cutoffGroupIndexContainer_.insert(beginIndex, endIndex);
    }

    void releaseCutoffGroupIndex(std::vector<int> indices) {
      cutoffGroupIndexContainer_.insert(indices);
    }
 
  private:

    IndexListContainer atomIndexContainer_;
    IndexListContainer rigidBodyIndexContainer_;
    IndexListContainer cutoffGroupIndexContainer_;
  };

} //end namespace OpenMD
#endif //UTILS_LOCALINDEXMANAGER_HPP
Revision:	1665
Committed:	Tue Nov 22 20:38:56 2011 UTC (13 years, 5 months ago) by gezelter
File size:	9269 byte(s)
Log Message:	updated copyright notices
#	Content
1	/*
2	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3	*
4	* The University of Notre Dame grants you ("Licensee") a
5	* non-exclusive, royalty free, license to use, modify and
6	* redistribute this software in source and binary code form, provided
7	* that the following conditions are met:
8	*
9	* 1. Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.
11	*
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.
16	*
17	* This software is provided "AS IS," without a warranty of any
18	* kind. All express or implied conditions, representations and
19	* warranties, including any implied warranty of merchantability,
20	* fitness for a particular purpose or non-infringement, are hereby
21	* excluded. The University of Notre Dame and its licensors shall not
22	* be liable for any damages suffered by licensee as a result of
23	* using, modifying or distributing the software or its
24	* derivatives. In no event will the University of Notre Dame or its
25	* licensors be liable for any lost revenue, profit or data, or for
26	* direct, indirect, special, consequential, incidental or punitive
27	* damages, however caused and regardless of the theory of liability,
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, 24107 (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	/**
44	* @file LocalIndexManager.hpp
45	* @author tlin
46	* @date 11/02/2004
47	* @version 1.0
48	*/
49
50	#ifndef UTILS_LOCALINDEXMANAGER_HPP
51	#define UTILS_LOCALINDEXMANAGER_HPP
52	#include <algorithm>
53	#include <iostream>
54	#include <cassert>
55	#include <list>
56	#include <utility>
57
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;
69
70
71	IndexListContainer(int minIndex = 0, int maxIndex = MAX_INTEGER)
72	:minIndex_(minIndex), maxIndex_(maxIndex) {
73
74	indexContainer_.push_back(std::make_pair(minIndex, maxIndex));
75	}
76
77	int pop() {
78
79	if (indexContainer_.empty()) {
80	std::cerr << "" << std::endl;
81	}
82
83	IndexListContainerIterator i = indexContainer_.begin();
84	int result;
85
86	result = indexContainer_.front().first;
87
88	if (indexContainer_.front().first == indexContainer_.front().second) {
89	indexContainer_.pop_front();
90	} else if (indexContainer_.front().first < indexContainer_.front().second) {
91	++indexContainer_.front().first;
92	} else {
93	std::cerr << "" << std::endl;
94	}
95
96	return result;
97	}
98
99
100	/**
101	*
102	*/
103	void insert(int index) {
104	IndexListContainerIterator insertPos = internalInsert(index, index);
105	merge(insertPos);
106	}
107
108	/**
109	* Reclaims an index range
110	* @param beginIndex
111	* @param endIndex
112	*/
113	void insert(int beginIndex, int endIndex) {
114	IndexListContainerIterator insertPos = internalInsert(beginIndex, endIndex);
115	merge(insertPos);
116	}
117
118	/**
119	* Reclaims an index array.
120	* @param indices
121	*/
122	void insert(std::vector<int>& indices){
123
124	if (indices.empty()) {
125	return;
126	}
127
128	std::sort(indices.begin(), indices.end());
129	std::unique(indices.begin(), indices.end());
130
131	std::vector<int>::iterator i;
132	IndexListContainerIterator insertPos;
133	int beginIndex;
134
135	beginIndex = indices[0];
136
137	for ( i = indices.begin() + 1 ; i != indices.end(); ++i) {
138	if (i != (i -1) + 1) {
139	insert(beginIndex, *(i-1));
140	beginIndex = *i;
141	}
142	}
143
144
145	}
146
147	std::vector<int> getIndicesBefore(int index) {
148	std::vector<int> result;
149	IndexListContainerIterator i;
150
151	for(i = indexContainer_.begin(); i != indexContainer_.end(); ++i) {
152	if ((*i).first > index) {
153	//we locate the node whose minimum index is greater that index
154	indexContainer_.erase(indexContainer_.begin(), i);
155	break;
156	} else if ((*i).second < index) {
157	//The biggest index current node hold is less than the index we want
158	for (int j = (i).first; j <= (i).second; ++j) {
159	result.push_back(j);
160	}
161	continue;
162	} else if ((i).first == (i).second) {
163	//the index happen to equal to a node which only contains one index
164	result.push_back((*i).first);
165	indexContainer_.erase(indexContainer_.begin(), i);
166	break;
167	} else {
168
169	for (int j = (*i).first; j < index; ++j) {
170	result.push_back(j);
171	}
172
173	(*i).first = index;
174	indexContainer_.erase(indexContainer_.begin(), i);
175	break;
176	}
177
178	}
179
180	return result;
181
182	}
183
184	int getMaxIndex() {
185	return maxIndex_;
186	}
187
188	private:
189
190	IndexListContainerIterator internalInsert(int beginIndex, int endIndex) {
191
192	if (beginIndex > endIndex) {
193	std::swap(beginIndex, endIndex);
194	std::cerr << "" << std::endl;
195	}
196
197	if (endIndex > maxIndex_) {
198	std::cerr << "" << std::endl;
199	}
200
201
202	IndexListContainerIterator j;
203
204	IndexListContainerIterator i = indexContainer_.begin();
205	for (; i != indexContainer_.end(); ++i) {
206	if ((*i).first > endIndex) {
207	indexContainer_.insert(i, std::make_pair(beginIndex, endIndex));
208	return --i;
209	} else if ((*i).second < beginIndex) {
210	continue;
211	} else {
212	std::cerr << "" << std::endl;
213	}
214	}
215
216	indexContainer_.push_back(std::make_pair(beginIndex, endIndex));
217	return --indexContainer_.end();
218
219	}
220
221	void merge(IndexListContainerIterator i) {
222	IndexListContainerIterator j;
223
224	//check whether current node can be merged with its previous node
225	if ( i != indexContainer_.begin()) {
226	j = i;
227	--j;
228	if (j != indexContainer_.begin() && (j).second + 1 == (i).first) {
229	(i).first = (j).first;
230	indexContainer_.erase(j);
231	}
232	}
233
234	//check whether current node can be merged with its next node
235	if ( i != indexContainer_.end()) {
236	j = i;
237	++j;
238
239	if (j != indexContainer_.end() && (i).second + 1 == (j).first) {
240	(i).second = (j).second;
241	indexContainer_.erase(j);
242	}
243	}
244
245	}
246	int minIndex_;
247	int maxIndex_;
248	std::list<std::pair<int, int> > indexContainer_;
249	};
250
251
252	/**
253	* @class LocalIndexManager LocalIndexManager.hpp "utils/LocalIndexManager.hpp"
254	* @brief
255	*/
256	class LocalIndexManager {
257	public:
258
259	int getNextAtomIndex() {
260	return atomIndexContainer_.pop();
261	}
262
263	std::vector<int> getAtomIndicesBefore(int index) {
264	return atomIndexContainer_.getIndicesBefore(index);
265	}
266
267	void releaseAtomIndex(int index) {
268	atomIndexContainer_.insert(index);
269	}
270
271	void releaseAtomIndex(int beginIndex, int endIndex) {
272	atomIndexContainer_.insert(beginIndex, endIndex);
273	}
274
275	void releaseAtomIndex(std::vector<int> indices) {
276	atomIndexContainer_.insert(indices);
277	}
278
279	int getNextRigidBodyIndex() {
280	return rigidBodyIndexContainer_.pop();
281	}
282
283	std::vector<int> getRigidBodyIndicesBefore(int index) {
284	return rigidBodyIndexContainer_.getIndicesBefore(index);
285	}
286
287	void releaseRigidBodyIndex(int index) {
288	rigidBodyIndexContainer_.insert(index);
289	}
290
291	void releaseRigidBodyIndex(int beginIndex, int endIndex) {
292	rigidBodyIndexContainer_.insert(beginIndex, endIndex);
293	}
294
295	void releaseRigidBodyIndex(std::vector<int> indices) {
296	rigidBodyIndexContainer_.insert(indices);
297	}
298
299	int getNextCutoffGroupIndex() {
300	return cutoffGroupIndexContainer_.pop();
301	}
302
303	std::vector<int> getCutoffGroupIndicesBefore(int index) {
304	return cutoffGroupIndexContainer_.getIndicesBefore(index);
305	}
306
307	void releaseCutoffGroupIndex(int index) {
308	cutoffGroupIndexContainer_.insert(index);
309	}
310
311	void releaseCutoffGroupIndex(int beginIndex, int endIndex) {
312	cutoffGroupIndexContainer_.insert(beginIndex, endIndex);
313	}
314
315	void releaseCutoffGroupIndex(std::vector<int> indices) {
316	cutoffGroupIndexContainer_.insert(indices);
317	}
318
319	private:
320
321	IndexListContainer atomIndexContainer_;
322	IndexListContainer rigidBodyIndexContainer_;
323	IndexListContainer cutoffGroupIndexContainer_;
324	};
325
326	} //end namespace OpenMD
327	#endif //UTILS_LOCALINDEXMANAGER_HPP