src/selection/SelectionSet.cpp

/*
 * 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, 234107 (2008).          
 * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
 */

#ifdef IS_MPI
#include <mpi.h>
#endif

#include <algorithm>
#include <cassert>
#include <string>
#include <iterator>

#include "selection/SelectionSet.hpp"
#include "utils/Algorithm.hpp"

namespace OpenMD {

  SelectionSet::SelectionSet(std::vector<int> nbits) {
    bitsets_.resize(N_SELECTIONTYPES);
    for (int i = 0; i < N_SELECTIONTYPES; i++)
      bitsets_[i] = OpenMDBitSet(nbits[i]);
    clearAll();        
  }
  
  std::vector<int> SelectionSet::countBits() {
    std::vector<int> result(N_SELECTIONTYPES, 0);
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      result[i] = bitsets_[i].countBits();   
    return result;
  }

  void SelectionSet::flip(std::vector<int> bitIndex) { 
    for (int i = 0; i < N_SELECTIONTYPES; i++)
      bitsets_[i].flip(bitIndex[i]);
  }

  void SelectionSet::flip(std::vector<int> fromIndex, 
                          std::vector<int> toIndex) {
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      bitsets_[i].flip(fromIndex[i], toIndex[i]);
  }
  
  void SelectionSet::flip() {
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      bitsets_[i].flip();
  }

  std::vector<bool> SelectionSet::get(std::vector<int> bitIndex) {  
    std::vector<bool> result(N_SELECTIONTYPES);
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      result[i] = bitsets_[i].get(bitIndex[i]);
    return result;
  }

  SelectionSet SelectionSet::get(std::vector<int> fromIndex, 
                                 std::vector<int> toIndex) {
    SelectionSet result;

    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      result.bitsets_[i] = bitsets_[i].get(fromIndex[i], toIndex[i]);
    
    return result;
  }

  std::vector<bool> SelectionSet::any() {
    std::vector<bool> result(N_SELECTIONTYPES);
    for (int i = 0; i < N_SELECTIONTYPES; i++)       
      result[i] = bitsets_[i].any();
    return result;
  }

  std::vector<bool> SelectionSet::none() {
    std::vector<bool> result(N_SELECTIONTYPES);
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      result[i] = bitsets_[i].none();
    return result;
  }

  std::vector<int> SelectionSet::firstOffBit() const {
    std::vector<int> result(N_SELECTIONTYPES);
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      result[i] = bitsets_[i].firstOffBit();
    return result;
  }
  
  std::vector<int> SelectionSet::nextOffBit(std::vector<int> fromIndex) const {
    std::vector<int> result(N_SELECTIONTYPES);
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      result[i] = bitsets_[i].nextOffBit(fromIndex[i]);
    return result;
  }

  std::vector<int> SelectionSet::firstOnBit() const {
    std::vector<int> result(N_SELECTIONTYPES);
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      result[i] = bitsets_[i].firstOnBit();
    return result;
  }

  std::vector<int> SelectionSet::nextOnBit(std::vector<int> fromIndex) const {
    std::vector<int> result(N_SELECTIONTYPES);
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      result[i] = bitsets_[i].nextOnBit(fromIndex[i]);
    return result;
  }

  void SelectionSet::andOperator (const SelectionSet& ss) {
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      bitsets_[i] &= ss.bitsets_[i];
  }

  void SelectionSet::orOperator (const SelectionSet& ss) {
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      bitsets_[i] |= ss.bitsets_[i];
  }

  void SelectionSet::xorOperator (const SelectionSet& ss) {
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      bitsets_[i] ^= ss.bitsets_[i];
  }
   
  //void SelectionSet::setBits(std::vector<int> fromIndex, 
  //                           std::vector<int> toIndex, bool value) {
  //  for (int i = 0; i < N_SELECTIONTYPES; i++) 
  //    bitsets_[i].setBits(fromIndex[i], toIndex[i], value);
  //}

  void SelectionSet::clearAll() {  
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      bitsets_[i].clearAll();  
  }         

  void SelectionSet::setAll() {  
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      bitsets_[i].setAll();  
  }

  std::vector<int> SelectionSet::size() const {  
    std::vector<int> result(N_SELECTIONTYPES);
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      result[i] = bitsets_[i].size();   
    return result;
  }
  
  void SelectionSet::resize(std::vector<int> nbits) {
    for (int i = 0; i < N_SELECTIONTYPES; i++) 
      bitsets_[i].resize(nbits[i]);   
  }

  SelectionSet operator| (const SelectionSet& ss1, const SelectionSet& ss2) {
    SelectionSet result(ss1);
    for (int i = 0; i < N_SELECTIONTYPES; i++)           
      result.bitsets_[i] |= ss2.bitsets_[i];
    return result;
  }

  SelectionSet operator& (const SelectionSet& ss1, const SelectionSet& ss2) {
    SelectionSet result(ss1);
    for (int i = 0; i < N_SELECTIONTYPES; i++)           
      result.bitsets_[i] &= ss2.bitsets_[i];
    return result;
  }

  SelectionSet operator^ (const SelectionSet& ss1, const SelectionSet& ss2) {
    SelectionSet result(ss1);
    for (int i = 0; i < N_SELECTIONTYPES; i++)           
      result.bitsets_[i] ^= ss2.bitsets_[i];
    return result;
  }

  SelectionSet operator- (const SelectionSet& ss1, const SelectionSet& ss2) {
    SelectionSet result(ss1);
    for (int i = 0; i < N_SELECTIONTYPES; i++)           
      result.bitsets_[i] -= ss2.bitsets_[i];
    return result;
  }

  bool operator== (const SelectionSet & ss1, const SelectionSet &ss2) {

    for (int i = 0; i < N_SELECTIONTYPES; i++) {
      assert(ss1.bitsets_[i].size() == ss2.bitsets_[i].size());      
      if (!(ss1.bitsets_[i] == ss2.bitsets_[i])) return false;
    }
      
    return true;
  }  

  SelectionSet SelectionSet::parallelReduce() {

    SelectionSet result;
    for (int i = 0; i < N_SELECTIONTYPES; i++)
      result.bitsets_[i] = bitsets_[i].parallelReduce();
    
    return result;
  }


  //std::istream& operator>> ( std::istream& is, const OpenMDBitSet& bs) {
  //
  //    return is;
  //}

  std::ostream& operator<< ( std::ostream& os, const SelectionSet& ss) {
    for (int i = 0; i < N_SELECTIONTYPES; i++)
      os << "SelectionSet[" << i << "] = " << ss.bitsets_[i] << std::endl;
    return os;
  }

  //void SelectionSet::setBit(std::vector<int> bitIndex, bool value) { 
  //  for (int i = 0; i < N_SELECTIONTYPES; i++)      
  //    bitsets_[i].setBit(bitIndex[i], value);
  //}
          
}
Revision:	1953
Committed:	Thu Dec 5 18:19:26 2013 UTC (11 years, 4 months ago) by gezelter
File size:	8438 byte(s)
Log Message:	Rewrote much of selection module, added a bond correlation function
#	User	Rev	Content
1	gezelter	1953	/*
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, 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			#ifdef IS_MPI
44			#include <mpi.h>
45			#endif
46
47			#include <algorithm>
48			#include <cassert>
49			#include <string>
50			#include <iterator>
51
52			#include "selection/SelectionSet.hpp"
53			#include "utils/Algorithm.hpp"
54
55			namespace OpenMD {
56
57			SelectionSet::SelectionSet(std::vector<int> nbits) {
58			bitsets_.resize(N_SELECTIONTYPES);
59			for (int i = 0; i < N_SELECTIONTYPES; i++)
60			bitsets_[i] = OpenMDBitSet(nbits[i]);
61			clearAll();
62			}
63
64			std::vector<int> SelectionSet::countBits() {
65			std::vector<int> result(N_SELECTIONTYPES, 0);
66			for (int i = 0; i < N_SELECTIONTYPES; i++)
67			result[i] = bitsets_[i].countBits();
68			return result;
69			}
70
71			void SelectionSet::flip(std::vector<int> bitIndex) {
72			for (int i = 0; i < N_SELECTIONTYPES; i++)
73			bitsets_[i].flip(bitIndex[i]);
74			}
75
76			void SelectionSet::flip(std::vector<int> fromIndex,
77			std::vector<int> toIndex) {
78			for (int i = 0; i < N_SELECTIONTYPES; i++)
79			bitsets_[i].flip(fromIndex[i], toIndex[i]);
80			}
81
82			void SelectionSet::flip() {
83			for (int i = 0; i < N_SELECTIONTYPES; i++)
84			bitsets_[i].flip();
85			}
86
87			std::vector<bool> SelectionSet::get(std::vector<int> bitIndex) {
88			std::vector<bool> result(N_SELECTIONTYPES);
89			for (int i = 0; i < N_SELECTIONTYPES; i++)
90			result[i] = bitsets_[i].get(bitIndex[i]);
91			return result;
92			}
93
94			SelectionSet SelectionSet::get(std::vector<int> fromIndex,
95			std::vector<int> toIndex) {
96			SelectionSet result;
97
98			for (int i = 0; i < N_SELECTIONTYPES; i++)
99			result.bitsets_[i] = bitsets_[i].get(fromIndex[i], toIndex[i]);
100
101			return result;
102			}
103
104			std::vector<bool> SelectionSet::any() {
105			std::vector<bool> result(N_SELECTIONTYPES);
106			for (int i = 0; i < N_SELECTIONTYPES; i++)
107			result[i] = bitsets_[i].any();
108			return result;
109			}
110
111			std::vector<bool> SelectionSet::none() {
112			std::vector<bool> result(N_SELECTIONTYPES);
113			for (int i = 0; i < N_SELECTIONTYPES; i++)
114			result[i] = bitsets_[i].none();
115			return result;
116			}
117
118			std::vector<int> SelectionSet::firstOffBit() const {
119			std::vector<int> result(N_SELECTIONTYPES);
120			for (int i = 0; i < N_SELECTIONTYPES; i++)
121			result[i] = bitsets_[i].firstOffBit();
122			return result;
123			}
124
125			std::vector<int> SelectionSet::nextOffBit(std::vector<int> fromIndex) const {
126			std::vector<int> result(N_SELECTIONTYPES);
127			for (int i = 0; i < N_SELECTIONTYPES; i++)
128			result[i] = bitsets_[i].nextOffBit(fromIndex[i]);
129			return result;
130			}
131
132			std::vector<int> SelectionSet::firstOnBit() const {
133			std::vector<int> result(N_SELECTIONTYPES);
134			for (int i = 0; i < N_SELECTIONTYPES; i++)
135			result[i] = bitsets_[i].firstOnBit();
136			return result;
137			}
138
139			std::vector<int> SelectionSet::nextOnBit(std::vector<int> fromIndex) const {
140			std::vector<int> result(N_SELECTIONTYPES);
141			for (int i = 0; i < N_SELECTIONTYPES; i++)
142			result[i] = bitsets_[i].nextOnBit(fromIndex[i]);
143			return result;
144			}
145
146			void SelectionSet::andOperator (const SelectionSet& ss) {
147			for (int i = 0; i < N_SELECTIONTYPES; i++)
148			bitsets_[i] &= ss.bitsets_[i];
149			}
150
151			void SelectionSet::orOperator (const SelectionSet& ss) {
152			for (int i = 0; i < N_SELECTIONTYPES; i++)
153			bitsets_[i] \|= ss.bitsets_[i];
154			}
155
156			void SelectionSet::xorOperator (const SelectionSet& ss) {
157			for (int i = 0; i < N_SELECTIONTYPES; i++)
158			bitsets_[i] ^= ss.bitsets_[i];
159			}
160
161			//void SelectionSet::setBits(std::vector<int> fromIndex,
162			// std::vector<int> toIndex, bool value) {
163			// for (int i = 0; i < N_SELECTIONTYPES; i++)
164			// bitsets_[i].setBits(fromIndex[i], toIndex[i], value);
165			//}
166
167			void SelectionSet::clearAll() {
168			for (int i = 0; i < N_SELECTIONTYPES; i++)
169			bitsets_[i].clearAll();
170			}
171
172			void SelectionSet::setAll() {
173			for (int i = 0; i < N_SELECTIONTYPES; i++)
174			bitsets_[i].setAll();
175			}
176
177			std::vector<int> SelectionSet::size() const {
178			std::vector<int> result(N_SELECTIONTYPES);
179			for (int i = 0; i < N_SELECTIONTYPES; i++)
180			result[i] = bitsets_[i].size();
181			return result;
182			}
183
184			void SelectionSet::resize(std::vector<int> nbits) {
185			for (int i = 0; i < N_SELECTIONTYPES; i++)
186			bitsets_[i].resize(nbits[i]);
187			}
188
189			SelectionSet operator\| (const SelectionSet& ss1, const SelectionSet& ss2) {
190			SelectionSet result(ss1);
191			for (int i = 0; i < N_SELECTIONTYPES; i++)
192			result.bitsets_[i] \|= ss2.bitsets_[i];
193			return result;
194			}
195
196			SelectionSet operator& (const SelectionSet& ss1, const SelectionSet& ss2) {
197			SelectionSet result(ss1);
198			for (int i = 0; i < N_SELECTIONTYPES; i++)
199			result.bitsets_[i] &= ss2.bitsets_[i];
200			return result;
201			}
202
203			SelectionSet operator^ (const SelectionSet& ss1, const SelectionSet& ss2) {
204			SelectionSet result(ss1);
205			for (int i = 0; i < N_SELECTIONTYPES; i++)
206			result.bitsets_[i] ^= ss2.bitsets_[i];
207			return result;
208			}
209
210			SelectionSet operator- (const SelectionSet& ss1, const SelectionSet& ss2) {
211			SelectionSet result(ss1);
212			for (int i = 0; i < N_SELECTIONTYPES; i++)
213			result.bitsets_[i] -= ss2.bitsets_[i];
214			return result;
215			}
216
217			bool operator== (const SelectionSet & ss1, const SelectionSet &ss2) {
218
219			for (int i = 0; i < N_SELECTIONTYPES; i++) {
220			assert(ss1.bitsets_[i].size() == ss2.bitsets_[i].size());
221			if (!(ss1.bitsets_[i] == ss2.bitsets_[i])) return false;
222			}
223
224			return true;
225			}
226
227			SelectionSet SelectionSet::parallelReduce() {
228
229			SelectionSet result;
230			for (int i = 0; i < N_SELECTIONTYPES; i++)
231			result.bitsets_[i] = bitsets_[i].parallelReduce();
232
233			return result;
234			}
235
236
237
238			//std::istream& operator>> ( std::istream& is, const OpenMDBitSet& bs) {
239			//
240			// return is;
241			//}
242
243			std::ostream& operator<< ( std::ostream& os, const SelectionSet& ss) {
244			for (int i = 0; i < N_SELECTIONTYPES; i++)
245			os << "SelectionSet[" << i << "] = " << ss.bitsets_[i] << std::endl;
246			return os;
247			}
248
249			//void SelectionSet::setBit(std::vector<int> bitIndex, bool value) {
250			// for (int i = 0; i < N_SELECTIONTYPES; i++)
251			// bitsets_[i].setBit(bitIndex[i], value);
252			//}
253
254			}