OpenMD 3.0
Molecular Dynamics in the Open
Loading...
Searching...
No Matches
TypeContainer.hpp
Go to the documentation of this file.
1/*
2 * Copyright (c) 2004-present, The University of Notre Dame. All rights
3 * reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 * SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your
32 * research, please cite the appropriate papers when you publish your
33 * work. Good starting points are:
34 *
35 * [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
36 * [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
37 * [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).
38 * [4] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
39 * [5] Kuang & Gezelter, Mol. Phys., 110, 691-701 (2012).
40 * [6] Lamichhane, Gezelter & Newman, J. Chem. Phys. 141, 134109 (2014).
41 * [7] Lamichhane, Newman & Gezelter, J. Chem. Phys. 141, 134110 (2014).
42 * [8] Bhattarai, Newman & Gezelter, Phys. Rev. B 99, 094106 (2019).
43 */
44
45/**
46 * @file TypeContainer.hpp
47 * @author tlin
48 * @date 11/04/2004
49 * @version 1.0
50 */
51
52#ifndef UTILS_TYPECONTAINER_HPP
53#define UTILS_TYPECONTAINER_HPP
54
55#include <algorithm>
56#include <map>
57#include <vector>
58
59#include "utils/MemoryUtils.hpp"
60#include "utils/Utility.hpp"
61
62namespace OpenMD {
63
64 /**
65 * @class TypeContainer TypeContainer.hpp "utils/TypeContainer.hpp"
66 */
67 template<class ElemType, int SIZE>
69 public:
70 using ElemPtr = ElemType*;
71 using KeyType = std::vector<std::string>;
72 using KeyTypeIterator = typename KeyType::iterator;
73 using ValueType = std::pair<int, ElemPtr>;
74 using MapType = typename std::map<KeyType, ValueType>;
75 using MapTypeIterator = typename std::map<KeyType, ValueType>::iterator;
76 using value_type = typename MapType::value_type;
77 using MutableValues = typename std::vector<int>;
78
79 TypeContainer() : index_(0) {}
80
81 ~TypeContainer() { Utils::deletePointers(data_); }
82
83 bool add(KeyType& keys, ElemPtr elem) {
84 assert(keys.size() == SIZE);
85 assert(elem);
86 return data_.insert(value_type(keys, std::make_pair(index_++, elem)))
87 .second;
88 }
89
90 bool replace(KeyType& keys, ElemPtr elem) {
91 assert(keys.size() == SIZE);
92 assert(elem);
93
94 MapTypeIterator i;
95 i = data_.find(keys);
96 if (i != data_.end()) {
97 data_[keys] = std::make_pair((i->second).first, elem);
98 return true;
99 } else {
100 return data_.insert(value_type(keys, std::make_pair(index_++, elem)))
101 .second;
102 }
103 }
104
105 /** Exact Match */
106 ElemPtr find(KeyType& keys) {
107 assert(keys.size() == SIZE);
108 MapTypeIterator i;
109
110 i = data_.find(keys);
111 if (i != data_.end()) { return (i->second).second; }
112
113 KeyType reversedKeys = keys;
114 std::reverse(reversedKeys.begin(), reversedKeys.end());
115
116 i = data_.find(reversedKeys);
117 if (i != data_.end()) {
118 return (i->second).second;
119 } else {
120 return NULL;
121 }
122 }
123
124 ElemPtr permutedFindSkippingFirstElement(KeyType& keys) {
125 assert(keys.size() == SIZE);
126 MapTypeIterator i;
127
128 KeyType permutedKeys = keys;
129
130 // skip the first element:
131 KeyTypeIterator start;
132 start = permutedKeys.begin();
133 ++start;
134
135 std::sort(start, permutedKeys.end());
136
137 do {
138 i = data_.find(permutedKeys);
139 if (i != data_.end()) { return (i->second).second; }
140 } while (std::next_permutation(start, permutedKeys.end()));
141
142 return NULL;
143 }
144
145 /**
146 * @todo
147 */
148 ElemPtr find(KeyType& keys, const std::string& wildCard) {
149 assert(keys.size() == SIZE);
150
151 std::vector<KeyTypeIterator> iterCont;
152 KeyType replacedKey;
153 MapTypeIterator i;
154 std::vector<ValueType> foundTypes;
155
156 while (replaceWithWildCard(iterCont, keys, replacedKey, wildCard)) {
157 i = data_.find(replacedKey);
158 if (i != data_.end()) { foundTypes.push_back(i->second); }
159 }
160
161 // reverse the order of keys
162 KeyType reversedKeys = keys;
163 std::reverse(reversedKeys.begin(), reversedKeys.end());
164
165 // if the reversedKeys is the same as keys, just skip it
166 if (reversedKeys != keys) {
167 // empty the iterator container
168 iterCont.clear();
169
170 while (replaceWithWildCard(iterCont, reversedKeys, replacedKey,
171 wildCard)) {
172 i = data_.find(replacedKey);
173 if (i != data_.end()) { foundTypes.push_back(i->second); }
174 }
175
176 // replaceWithWildCard can not generate this particular sequence, we
177 // have to do it manually
178 KeyType allWildCards(SIZE, wildCard);
179 i = data_.find(replacedKey);
180 if (i != data_.end()) { foundTypes.push_back(i->second); }
181 }
182
183 typename std::vector<ValueType>::iterator j;
184 j = std::min_element(foundTypes.begin(), foundTypes.end());
185
186 return j == foundTypes.end() ? NULL : j->second;
187 }
188
189 size_t size() { return data_.size(); }
190
191 ElemPtr beginType(MapTypeIterator& i) {
192 i = data_.begin();
193 return i != data_.end() ? (i->second).second : NULL;
194 }
195
196 ElemPtr nextType(MapTypeIterator& i) {
197 ++i;
198 return i != data_.end() ? (i->second).second : NULL;
199 }
200
201 KeyType getKeys(MapTypeIterator& i) { return i->first; }
202
203 private:
204 int index_;
205 MapType data_;
206 };
207} // namespace OpenMD
208
209#endif // UTILS_TYPECONTAINER_HPP
ElemPtr find(KeyType &keys)
Exact Match.
ElemPtr find(KeyType &keys, const std::string &wildCard)
This basic Periodic Table class was originally taken from the data.cpp file in OpenBabel.
bool replaceWithWildCard(std::vector< std::vector< std::string >::iterator > &cont, std::vector< std::string > &sequence, std::vector< std::string > &result, const std::string &wildCard)
iteratively replace the sequence with wild cards
Definition Utility.cpp:55