[bcf653] | 1 | /*
|
---|
| 2 | * Project: MoleCuilder
|
---|
| 3 | * Description: creates and alters molecular systems
|
---|
[0aa122] | 4 | * Copyright (C) 2010-2012 University of Bonn. All rights reserved.
|
---|
[5aaa43] | 5 | * Copyright (C) 2013 Frederik Heber. All rights reserved.
|
---|
[94d5ac6] | 6 | *
|
---|
| 7 | *
|
---|
| 8 | * This file is part of MoleCuilder.
|
---|
| 9 | *
|
---|
| 10 | * MoleCuilder is free software: you can redistribute it and/or modify
|
---|
| 11 | * it under the terms of the GNU General Public License as published by
|
---|
| 12 | * the Free Software Foundation, either version 2 of the License, or
|
---|
| 13 | * (at your option) any later version.
|
---|
| 14 | *
|
---|
| 15 | * MoleCuilder is distributed in the hope that it will be useful,
|
---|
| 16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
| 18 | * GNU General Public License for more details.
|
---|
| 19 | *
|
---|
| 20 | * You should have received a copy of the GNU General Public License
|
---|
| 21 | * along with MoleCuilder. If not, see <http://www.gnu.org/licenses/>.
|
---|
[bcf653] | 22 | */
|
---|
| 23 |
|
---|
[6bc51d] | 24 | /*
|
---|
| 25 | * TremoloParser.cpp
|
---|
| 26 | *
|
---|
| 27 | * Created on: Mar 2, 2010
|
---|
| 28 | * Author: metzler
|
---|
| 29 | */
|
---|
| 30 |
|
---|
[bf3817] | 31 | // include config.h
|
---|
| 32 | #ifdef HAVE_CONFIG_H
|
---|
| 33 | #include <config.h>
|
---|
| 34 | #endif
|
---|
| 35 |
|
---|
[ad011c] | 36 | #include "CodePatterns/MemDebug.hpp"
|
---|
[112b09] | 37 |
|
---|
[ad011c] | 38 | #include "CodePatterns/Assert.hpp"
|
---|
| 39 | #include "CodePatterns/Log.hpp"
|
---|
[4d4d33] | 40 | #include "CodePatterns/toString.hpp"
|
---|
[ad011c] | 41 | #include "CodePatterns/Verbose.hpp"
|
---|
[42127c] | 42 |
|
---|
[9131f3] | 43 | #include "TremoloParser.hpp"
|
---|
[42127c] | 44 |
|
---|
[6f0841] | 45 | #include "Atom/atom.hpp"
|
---|
[129204] | 46 | #include "Bond/bond.hpp"
|
---|
[ccb487] | 47 | #include "Box.hpp"
|
---|
[42127c] | 48 | #include "Descriptors/AtomIdDescriptor.hpp"
|
---|
[3bdb6d] | 49 | #include "Element/element.hpp"
|
---|
| 50 | #include "Element/periodentafel.hpp"
|
---|
[ccb487] | 51 | #include "LinearAlgebra/RealSpaceMatrix.hpp"
|
---|
[42127c] | 52 | #include "molecule.hpp"
|
---|
| 53 | #include "World.hpp"
|
---|
| 54 | #include "WorldTime.hpp"
|
---|
| 55 |
|
---|
[9131f3] | 56 |
|
---|
[9f8b01] | 57 | #include <algorithm>
|
---|
[05e2ed] | 58 | #include <boost/bind.hpp>
|
---|
[4795cd] | 59 | #include <boost/function.hpp>
|
---|
[ca331c] | 60 | #include <boost/lambda/lambda.hpp>
|
---|
[2034f3] | 61 | #include <boost/lexical_cast.hpp>
|
---|
[72d108] | 62 | #include <boost/tokenizer.hpp>
|
---|
[74a444] | 63 | #include <iostream>
|
---|
| 64 | #include <iomanip>
|
---|
[8bf9c6] | 65 | #include <map>
|
---|
| 66 | #include <sstream>
|
---|
[ca331c] | 67 | #include <string>
|
---|
[8bf9c6] | 68 | #include <vector>
|
---|
[9131f3] | 69 |
|
---|
[5a667d] | 70 | #include <boost/assign/list_of.hpp> // for 'map_list_of()'
|
---|
| 71 | #include <boost/assert.hpp>
|
---|
| 72 |
|
---|
[765f16] | 73 | // declare specialized static variables
|
---|
| 74 | const std::string FormatParserTrait<tremolo>::name = "tremolo";
|
---|
| 75 | const std::string FormatParserTrait<tremolo>::suffix = "data";
|
---|
| 76 | const ParserTypes FormatParserTrait<tremolo>::type = tremolo;
|
---|
| 77 |
|
---|
[5a667d] | 78 | // static instances
|
---|
| 79 | std::map<std::string, TremoloKey::atomDataKey> FormatParser<tremolo>::knownKeys =
|
---|
| 80 | boost::assign::map_list_of("x",TremoloKey::x)
|
---|
| 81 | ("u",TremoloKey::u)
|
---|
| 82 | ("F",TremoloKey::F)
|
---|
| 83 | ("stress",TremoloKey::stress)
|
---|
| 84 | ("Id",TremoloKey::Id)
|
---|
| 85 | ("neighbors",TremoloKey::neighbors)
|
---|
| 86 | ("imprData",TremoloKey::imprData)
|
---|
| 87 | ("GroupMeasureTypeNo",TremoloKey::GroupMeasureTypeNo)
|
---|
| 88 | ("type",TremoloKey::type)
|
---|
| 89 | ("extType",TremoloKey::extType)
|
---|
| 90 | ("name",TremoloKey::name)
|
---|
| 91 | ("resName",TremoloKey::resName)
|
---|
| 92 | ("chainID",TremoloKey::chainID)
|
---|
| 93 | ("resSeq",TremoloKey::resSeq)
|
---|
| 94 | ("occupancy",TremoloKey::occupancy)
|
---|
| 95 | ("tempFactor",TremoloKey::tempFactor)
|
---|
| 96 | ("segID",TremoloKey::segID)
|
---|
| 97 | ("Charge",TremoloKey::Charge)
|
---|
| 98 | ("charge",TremoloKey::charge)
|
---|
| 99 | ("GrpTypeNo",TremoloKey::GrpTypeNo)
|
---|
| 100 | ("torsion",TremoloKey::torsion)
|
---|
| 101 | (" ",TremoloKey::noKey); // with this we can detect invalid keys
|
---|
| 102 |
|
---|
[9131f3] | 103 | /**
|
---|
| 104 | * Constructor.
|
---|
| 105 | */
|
---|
[765f16] | 106 | FormatParser< tremolo >::FormatParser() :
|
---|
[05e2ed] | 107 | FormatParser_common(NULL),
|
---|
| 108 | idglobalizer(boost::bind(&FormatParser< tremolo >::getGlobalId, this, _1)),
|
---|
| 109 | idlocalizer(boost::bind(&FormatParser< tremolo >::getLocalId, this, _1))
|
---|
[765f16] | 110 | {
|
---|
[4d4d33] | 111 | createKnownTypesByIdentity();
|
---|
| 112 |
|
---|
| 113 | // invert knownKeys for debug output
|
---|
| 114 | for (std::map<std::string, TremoloKey::atomDataKey>::iterator iter = knownKeys.begin(); iter != knownKeys.end(); ++iter)
|
---|
| 115 | knownKeyNames.insert( make_pair( iter->second, iter->first) );
|
---|
| 116 |
|
---|
| 117 | additionalAtomData.clear();
|
---|
[9131f3] | 118 | }
|
---|
| 119 |
|
---|
[5a667d] | 120 |
|
---|
[9131f3] | 121 | /**
|
---|
| 122 | * Destructor.
|
---|
| 123 | */
|
---|
[765f16] | 124 | FormatParser< tremolo >::~FormatParser()
|
---|
| 125 | {
|
---|
[23fd43] | 126 | usedFields_save.clear();
|
---|
[b8d4a3] | 127 | additionalAtomData.clear();
|
---|
| 128 | }
|
---|
| 129 |
|
---|
| 130 | /**
|
---|
| 131 | * Loads atoms from a tremolo-formatted file.
|
---|
| 132 | *
|
---|
| 133 | * \param tremolo file
|
---|
| 134 | */
|
---|
[765f16] | 135 | void FormatParser< tremolo >::load(istream* file) {
|
---|
[8bf9c6] | 136 | std::string line;
|
---|
| 137 | std::string::size_type location;
|
---|
[b8d4a3] | 138 |
|
---|
[c0e28c] | 139 | // reset the id maps
|
---|
| 140 | resetIdAssociations();
|
---|
| 141 |
|
---|
[dc1d9e] | 142 | molecule *newmol = World::getInstance().createMolecule();
|
---|
[bd2390] | 143 | newmol->ActiveFlag = true;
|
---|
[b8d4a3] | 144 | while (file->good()) {
|
---|
| 145 | std::getline(*file, line, '\n');
|
---|
[23fd43] | 146 | // we only parse in the first ATOMDATA line
|
---|
| 147 | if (usedFields_load.empty()) {
|
---|
[b8d4a3] | 148 | location = line.find("ATOMDATA", 0);
|
---|
| 149 | if (location != string::npos) {
|
---|
[23fd43] | 150 | parseAtomDataKeysLine(line, location + 8, usedFields_load);
|
---|
[b8d4a3] | 151 | }
|
---|
| 152 | }
|
---|
| 153 | if (line.length() > 0 && line.at(0) != '#') {
|
---|
[dc1d9e] | 154 | readAtomDataLine(line, newmol);
|
---|
[b8d4a3] | 155 | }
|
---|
| 156 | }
|
---|
[23fd43] | 157 | LOG(3, "DEBUG: Local usedFields is: " << usedFields_load);
|
---|
[2e352f] | 158 |
|
---|
[9f8b01] | 159 | // refresh atom::nr and atom::name
|
---|
| 160 | std::vector<atomId_t> atoms(newmol->getAtomCount());
|
---|
| 161 | std::transform(newmol->begin(), newmol->end(), atoms.begin(),
|
---|
| 162 | boost::bind(&atom::getId, _1));
|
---|
| 163 | processNeighborInformation(atoms);
|
---|
[05e2ed] | 164 | adaptImprData(atoms);
|
---|
| 165 | adaptTorsion(atoms);
|
---|
[23fd43] | 166 |
|
---|
| 167 | // append usedFields to global usedFields, is made unique on save, clear after use
|
---|
| 168 | usedFields_save.insert(usedFields_save.end(), usedFields_load.begin(), usedFields_load.end());
|
---|
| 169 | usedFields_load.clear();
|
---|
[b8d4a3] | 170 | }
|
---|
| 171 |
|
---|
| 172 | /**
|
---|
[73916f] | 173 | * Saves the \a atoms into as a tremolo file.
|
---|
[b8d4a3] | 174 | *
|
---|
| 175 | * \param file where to save the state
|
---|
[73916f] | 176 | * \param atoms atoms to store
|
---|
[b8d4a3] | 177 | */
|
---|
[fac58f] | 178 | void FormatParser< tremolo >::save(
|
---|
| 179 | std::ostream* file,
|
---|
| 180 | const std::vector<const atom *> &AtomList) {
|
---|
[830b3e] | 181 | LOG(2, "DEBUG: Saving changes to tremolo.");
|
---|
[e97a44] | 182 |
|
---|
[23fd43] | 183 | // install default usedFields if empty so far
|
---|
| 184 | if (usedFields_save.empty()) {
|
---|
| 185 | // default behavior: use all possible keys on output
|
---|
| 186 | for (std::map<std::string, TremoloKey::atomDataKey>::iterator iter = knownKeys.begin();
|
---|
| 187 | iter != knownKeys.end(); ++iter)
|
---|
| 188 | if (iter->second != TremoloKey::noKey) // don't add noKey
|
---|
| 189 | usedFields_save.push_back(iter->first);
|
---|
| 190 | }
|
---|
| 191 | // make present usedFields_save unique
|
---|
| 192 | makeUsedFieldsUnique(usedFields_save);
|
---|
[a86cda] | 193 | LOG(1, "INFO: Global (with unique entries) usedFields_save is: " << usedFields_save);
|
---|
[23fd43] | 194 |
|
---|
| 195 | // distribute ids continuously
|
---|
| 196 | distributeContinuousIds(AtomList);
|
---|
| 197 |
|
---|
| 198 | // store atomdata
|
---|
| 199 | save_AtomDataLine(file);
|
---|
| 200 |
|
---|
| 201 | // store box
|
---|
| 202 | save_BoxLine(file);
|
---|
[b8d4a3] | 203 |
|
---|
[23fd43] | 204 | // store particles
|
---|
[fac58f] | 205 | for (std::vector<const atom*>::const_iterator atomIt = AtomList.begin();
|
---|
[23fd43] | 206 | atomIt != AtomList.end(); ++atomIt)
|
---|
| 207 | saveLine(file, *atomIt);
|
---|
| 208 | }
|
---|
[acd638] | 209 |
|
---|
[5b0581] | 210 | struct usedFieldsWeakComparator
|
---|
| 211 | {
|
---|
| 212 | /** Special comparator regards "neighbors=4" and "neighbors=2" as equal
|
---|
| 213 | *
|
---|
| 214 | * \note This one is used for making usedFields unique, i.e. throwing out the "smaller"
|
---|
| 215 | * neighbors.
|
---|
| 216 | */
|
---|
| 217 | bool operator()(const std::string &a, const std::string &b) const
|
---|
| 218 | {
|
---|
| 219 | // only compare up to first equality sign
|
---|
| 220 | return (a.substr(0, a.find_first_of('=')) == b.substr(0, b.find_first_of('=')));
|
---|
| 221 | }
|
---|
| 222 | };
|
---|
| 223 |
|
---|
| 224 | struct usedFieldsSpecialOrderer
|
---|
| 225 | {
|
---|
| 226 | /** Special string comparator that regards "neighbors=4" < "neighbors=2" as true and
|
---|
| 227 | * the other way round as false.
|
---|
| 228 | *
|
---|
| 229 | * Here, we implement the operator "\a < \b" in a special way to allow the
|
---|
| 230 | * above.
|
---|
| 231 | *
|
---|
| 232 | * \note This one is used for sorting usedFields in preparation for making it unique.
|
---|
| 233 | */
|
---|
| 234 | bool operator()(const std::string &a, const std::string &b) const
|
---|
| 235 | {
|
---|
| 236 | // only compare up to first equality sign
|
---|
| 237 | size_t a_equality = a.find_first_of('=');
|
---|
| 238 | size_t b_equality = b.find_first_of('=');
|
---|
| 239 | // if key before equality is not equal, return whether it is smaller or not
|
---|
| 240 | if (a.substr(0, a_equality) != b.substr(0, b_equality)) {
|
---|
| 241 | return a.substr(0, a_equality) < b.substr(0, b_equality);
|
---|
| 242 | } else { // now we know that the key before equality is the same in either string
|
---|
| 243 | // if one of them has no equality, the one with equality must go before
|
---|
| 244 | if ((a_equality != std::string::npos) && (b_equality == std::string::npos))
|
---|
| 245 | return true;
|
---|
| 246 | if ((a_equality == std::string::npos) && (b_equality != std::string::npos))
|
---|
| 247 | return false;
|
---|
| 248 | // if both don't have equality (and the token before is equal), it is not "<" but "=="
|
---|
| 249 | if ((a_equality == std::string::npos) && (b_equality == std::string::npos))
|
---|
| 250 | return false;
|
---|
| 251 | // if now both have equality sign, the larger value after it, must come first
|
---|
| 252 | return a.substr(a_equality, std::string::npos) > b.substr(b_equality, std::string::npos);
|
---|
| 253 | }
|
---|
| 254 | }
|
---|
| 255 | };
|
---|
| 256 |
|
---|
[23fd43] | 257 | /** Helper function to make \given fields unique while preserving the order of first appearance.
|
---|
| 258 | *
|
---|
| 259 | * As std::unique only removes element if equal to predecessor, a vector is only
|
---|
| 260 | * made unique if sorted beforehand. But sorting would destroy order of first
|
---|
| 261 | * appearance, hence we do the sorting on a temporary field and add the unique
|
---|
| 262 | * elements in the order as in \a fields.
|
---|
| 263 | *
|
---|
| 264 | * @param fields usedFields to make unique while preserving order of appearance
|
---|
| 265 | */
|
---|
[27cfde] | 266 | void FormatParser< tremolo >::makeUsedFieldsUnique(usedFields_t &fields) const
|
---|
[23fd43] | 267 | {
|
---|
| 268 | // std::unique only removes if predecessor is equal, not over whole range, hence do it manually
|
---|
[27cfde] | 269 | usedFields_t temp_fields(fields);
|
---|
[5b0581] | 270 | usedFieldsSpecialOrderer SpecialOrderer;
|
---|
| 271 | usedFieldsWeakComparator WeakComparator;
|
---|
| 272 | std::sort(temp_fields.begin(), temp_fields.end(), SpecialOrderer);
|
---|
[23fd43] | 273 | usedFields_t::iterator it =
|
---|
[5b0581] | 274 | std::unique(temp_fields.begin(), temp_fields.end(), WeakComparator);
|
---|
[23fd43] | 275 | temp_fields.erase(it, temp_fields.end());
|
---|
[27cfde] | 276 | usedFields_t usedfields(fields);
|
---|
| 277 | fields.clear();
|
---|
| 278 | fields.reserve(temp_fields.size());
|
---|
[23fd43] | 279 | // now go through each usedFields entry, check if in temp_fields and remove there on first occurence
|
---|
| 280 | for (usedFields_t::const_iterator iter = usedfields.begin();
|
---|
| 281 | iter != usedfields.end(); ++iter) {
|
---|
| 282 | usedFields_t::iterator uniqueiter =
|
---|
| 283 | std::find(temp_fields.begin(), temp_fields.end(), *iter);
|
---|
| 284 | if (uniqueiter != temp_fields.end()) {
|
---|
[27cfde] | 285 | fields.push_back(*iter);
|
---|
[23fd43] | 286 | // add only once to ATOMDATA
|
---|
| 287 | temp_fields.erase(uniqueiter);
|
---|
| 288 | }
|
---|
| 289 | }
|
---|
| 290 | ASSERT( temp_fields.empty(),
|
---|
| 291 | "FormatParser< tremolo >::save() - still unique entries left in temp_fields after unique?");
|
---|
| 292 | }
|
---|
| 293 |
|
---|
| 294 |
|
---|
| 295 | /** Resets and distributes the indices continuously.
|
---|
| 296 | *
|
---|
| 297 | * \param atoms atoms to store
|
---|
| 298 | */
|
---|
[fac58f] | 299 | void FormatParser< tremolo >::distributeContinuousIds(
|
---|
| 300 | const std::vector<const atom *> &AtomList)
|
---|
[23fd43] | 301 | {
|
---|
[812155] | 302 | resetIdAssociations();
|
---|
| 303 | atomId_t lastid = 0;
|
---|
[fac58f] | 304 | for (std::vector<const atom*>::const_iterator atomIt = AtomList.begin();
|
---|
[23fd43] | 305 | atomIt != AtomList.end(); ++atomIt)
|
---|
[812155] | 306 | associateLocaltoGlobalId(++lastid, (*atomIt)->getId());
|
---|
[23fd43] | 307 | }
|
---|
[812155] | 308 |
|
---|
[23fd43] | 309 | /** Store Atomdata line to \a file.
|
---|
| 310 | *
|
---|
| 311 | * @param file output stream
|
---|
| 312 | */
|
---|
| 313 | void FormatParser< tremolo >::save_AtomDataLine(std::ostream* file) const
|
---|
| 314 | {
|
---|
[b8d4a3] | 315 | *file << "# ATOMDATA";
|
---|
[23fd43] | 316 | for (usedFields_t::const_iterator it=usedFields_save.begin();
|
---|
| 317 | it != usedFields_save.end(); ++it)
|
---|
[b8d4a3] | 318 | *file << "\t" << *it;
|
---|
[23fd43] | 319 | *file << std::endl;
|
---|
| 320 | }
|
---|
[ccb487] | 321 |
|
---|
[23fd43] | 322 | /** Store Box info to \a file
|
---|
| 323 | *
|
---|
| 324 | * @param file output stream
|
---|
| 325 | */
|
---|
| 326 | void FormatParser< tremolo >::save_BoxLine(std::ostream* file) const
|
---|
| 327 | {
|
---|
[ccb487] | 328 | *file << "# Box";
|
---|
| 329 | const RealSpaceMatrix &M = World::getInstance().getDomain().getM();
|
---|
| 330 | for (size_t i=0; i<NDIM;++i)
|
---|
| 331 | for (size_t j=0; j<NDIM;++j)
|
---|
| 332 | *file << "\t" << M.at(i,j);
|
---|
| 333 | *file << std::endl;
|
---|
[b8d4a3] | 334 | }
|
---|
| 335 |
|
---|
[6bc86c] | 336 | /** Add default info, when new atom is added to World.
|
---|
| 337 | *
|
---|
| 338 | * @param id of atom
|
---|
| 339 | */
|
---|
[765f16] | 340 | void FormatParser< tremolo >::AtomInserted(atomId_t id)
|
---|
[6bc86c] | 341 | {
|
---|
[8bf9c6] | 342 | std::map<const atomId_t, TremoloAtomInfoContainer>::iterator iter = additionalAtomData.find(id);
|
---|
[6bc86c] | 343 | ASSERT(iter == additionalAtomData.end(),
|
---|
[765f16] | 344 | "FormatParser< tremolo >::AtomInserted() - additionalAtomData already present for newly added atom "
|
---|
[6bc86c] | 345 | +toString(id)+".");
|
---|
| 346 | // don't add entry, as this gives a default resSeq of 0 not the molecule id
|
---|
| 347 | // additionalAtomData.insert( std::make_pair(id, TremoloAtomInfoContainer()) );
|
---|
| 348 | }
|
---|
| 349 |
|
---|
| 350 | /** Remove additional AtomData info, when atom has been removed from World.
|
---|
| 351 | *
|
---|
| 352 | * @param id of atom
|
---|
| 353 | */
|
---|
[765f16] | 354 | void FormatParser< tremolo >::AtomRemoved(atomId_t id)
|
---|
[6bc86c] | 355 | {
|
---|
[8bf9c6] | 356 | std::map<const atomId_t, TremoloAtomInfoContainer>::iterator iter = additionalAtomData.find(id);
|
---|
[6bc86c] | 357 | // as we do not insert AtomData on AtomInserted, we cannot be assured of its presence
|
---|
| 358 | // ASSERT(iter != additionalAtomData.end(),
|
---|
[765f16] | 359 | // "FormatParser< tremolo >::AtomRemoved() - additionalAtomData is not present for atom "
|
---|
[6bc86c] | 360 | // +toString(id)+" to remove.");
|
---|
| 361 | if (iter != additionalAtomData.end())
|
---|
| 362 | additionalAtomData.erase(iter);
|
---|
| 363 | }
|
---|
| 364 |
|
---|
[4795cd] | 365 | template <class T>
|
---|
| 366 | T NoOp(const atom * const)
|
---|
| 367 | {
|
---|
| 368 | return T();
|
---|
| 369 | }
|
---|
| 370 |
|
---|
| 371 | template <class T>
|
---|
| 372 | void writeEntryFromAdditionalAtomData_ifpresent(
|
---|
| 373 | std::map<const atomId_t, TremoloAtomInfoContainer> &_additionalAtomData,
|
---|
| 374 | std::map<TremoloKey::atomDataKey, std::string> &_knownKeyNames,
|
---|
| 375 | std::ostream* _file,
|
---|
| 376 | const atom * const _currentAtom,
|
---|
| 377 | const TremoloKey::atomDataKey _currentField,
|
---|
| 378 | const typename boost::function<T (const atom * const)> _getter)
|
---|
| 379 | {
|
---|
| 380 | if (_additionalAtomData.count(_currentAtom->getId())) {
|
---|
| 381 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << ": "
|
---|
| 382 | << _additionalAtomData[_currentAtom->getId()].get(_currentField));
|
---|
| 383 | *_file << _additionalAtomData[_currentAtom->getId()].get(_currentField);
|
---|
| 384 | } else if (_additionalAtomData.count(_currentAtom->GetTrueFather()->getId())) {
|
---|
| 385 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " stuff from father: "
|
---|
| 386 | << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField));
|
---|
| 387 | *_file << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField);
|
---|
| 388 | } else {
|
---|
| 389 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " its default value: "
|
---|
| 390 | << _getter(_currentAtom));
|
---|
| 391 | *_file << _getter(_currentAtom);
|
---|
| 392 | }
|
---|
| 393 | *_file << "\t";
|
---|
| 394 | }
|
---|
| 395 |
|
---|
| 396 | template <class T>
|
---|
| 397 | void writeAdditionalAtomDataEntry(
|
---|
| 398 | std::map<const atomId_t, TremoloAtomInfoContainer> &_additionalAtomData,
|
---|
| 399 | std::map<TremoloKey::atomDataKey, std::string> &_knownKeyNames,
|
---|
| 400 | TremoloAtomInfoContainer &_defaultAdditionalData,
|
---|
| 401 | std::ostream* _file,
|
---|
| 402 | const atom * const _currentAtom,
|
---|
| 403 | const TremoloKey::atomDataKey _currentField)
|
---|
| 404 | {
|
---|
| 405 | if (_additionalAtomData.count(_currentAtom->getId())) {
|
---|
| 406 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << ": "
|
---|
| 407 | << _additionalAtomData[_currentAtom->getId()].get(_currentField));
|
---|
| 408 | *_file << _additionalAtomData[_currentAtom->getId()].get(_currentField);
|
---|
| 409 | } else if (_additionalAtomData.count(_currentAtom->GetTrueFather()->getId())) {
|
---|
| 410 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " stuff from father: "
|
---|
| 411 | << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField));
|
---|
| 412 | *_file << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField);
|
---|
| 413 | } else {
|
---|
| 414 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " its default value: "
|
---|
| 415 | << _defaultAdditionalData.get(_currentField));
|
---|
| 416 | *_file << _defaultAdditionalData.get(_currentField);
|
---|
| 417 | }
|
---|
| 418 | *_file << "\t";
|
---|
| 419 | }
|
---|
| 420 |
|
---|
| 421 | template <class T>
|
---|
| 422 | void writeEntryFromAdditionalAtomData_ifnotempty(
|
---|
| 423 | std::map<const atomId_t, TremoloAtomInfoContainer> &_additionalAtomData,
|
---|
| 424 | std::map<TremoloKey::atomDataKey, std::string> &_knownKeyNames,
|
---|
| 425 | TremoloAtomInfoContainer &_defaultAdditionalData,
|
---|
| 426 | std::ostream* _file,
|
---|
| 427 | const atom * const _currentAtom,
|
---|
| 428 | const TremoloKey::atomDataKey _currentField,
|
---|
| 429 | const typename boost::function<T (const atom * const)> _getter)
|
---|
| 430 | {
|
---|
| 431 | if (_additionalAtomData.count(_currentAtom->getId())) {
|
---|
| 432 | if (_additionalAtomData[_currentAtom->getId()].get(_currentField) != "-") {
|
---|
| 433 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << ": "
|
---|
| 434 | << _additionalAtomData[_currentAtom->getId()].get(_currentField));
|
---|
| 435 | *_file << _additionalAtomData[_currentAtom->getId()].get(_currentField);
|
---|
| 436 | } else {
|
---|
| 437 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " default value: "
|
---|
| 438 | << _getter(_currentAtom));
|
---|
| 439 | *_file << _getter(_currentAtom);
|
---|
| 440 | }
|
---|
| 441 | } else if (_additionalAtomData.count(_currentAtom->GetTrueFather()->getId())) {
|
---|
| 442 | if (_additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField) != "-") {
|
---|
| 443 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " stuff from father: "
|
---|
| 444 | << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField));
|
---|
| 445 | *_file << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField);
|
---|
| 446 | } else {
|
---|
| 447 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " default value from father: "
|
---|
| 448 | << _getter(_currentAtom->GetTrueFather()));
|
---|
| 449 | *_file << _getter(_currentAtom->GetTrueFather());
|
---|
| 450 | }
|
---|
| 451 | } else {
|
---|
| 452 | LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " its default value: "
|
---|
| 453 | << _getter(_currentAtom));
|
---|
| 454 | *_file << _getter(_currentAtom);
|
---|
| 455 | }
|
---|
| 456 | *_file << "\t";
|
---|
| 457 | }
|
---|
| 458 |
|
---|
[b8d4a3] | 459 | /**
|
---|
| 460 | * Writes one line of tremolo-formatted data to the provided stream.
|
---|
| 461 | *
|
---|
| 462 | * \param stream where to write the line to
|
---|
| 463 | * \param reference to the atom of which information should be written
|
---|
| 464 | */
|
---|
[fac58f] | 465 | void FormatParser< tremolo >::saveLine(
|
---|
| 466 | std::ostream* file,
|
---|
| 467 | const atom * const currentAtom)
|
---|
[23fd43] | 468 | {
|
---|
[b8d4a3] | 469 | TremoloKey::atomDataKey currentField;
|
---|
| 470 |
|
---|
[47d041] | 471 | LOG(4, "INFO: Saving atom " << *currentAtom << ", its father id is " << currentAtom->GetTrueFather()->getId());
|
---|
[4d4d33] | 472 |
|
---|
[23fd43] | 473 | for (usedFields_t::iterator it = usedFields_save.begin(); it != usedFields_save.end(); it++) {
|
---|
[b8d4a3] | 474 | currentField = knownKeys[it->substr(0, it->find("="))];
|
---|
| 475 | switch (currentField) {
|
---|
| 476 | case TremoloKey::x :
|
---|
| 477 | // for the moment, assume there are always three dimensions
|
---|
[47d041] | 478 | LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getPosition());
|
---|
[d74077] | 479 | *file << currentAtom->at(0) << "\t";
|
---|
| 480 | *file << currentAtom->at(1) << "\t";
|
---|
| 481 | *file << currentAtom->at(2) << "\t";
|
---|
[b8d4a3] | 482 | break;
|
---|
| 483 | case TremoloKey::u :
|
---|
| 484 | // for the moment, assume there are always three dimensions
|
---|
[47d041] | 485 | LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getAtomicVelocity());
|
---|
[bce72c] | 486 | *file << currentAtom->getAtomicVelocity()[0] << "\t";
|
---|
| 487 | *file << currentAtom->getAtomicVelocity()[1] << "\t";
|
---|
| 488 | *file << currentAtom->getAtomicVelocity()[2] << "\t";
|
---|
[b8d4a3] | 489 | break;
|
---|
[e6e4a0] | 490 | case TremoloKey::F :
|
---|
| 491 | // for the moment, assume there are always three dimensions
|
---|
| 492 | LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getAtomicForce());
|
---|
| 493 | *file << currentAtom->getAtomicForce()[0] << "\t";
|
---|
| 494 | *file << currentAtom->getAtomicForce()[1] << "\t";
|
---|
| 495 | *file << currentAtom->getAtomicForce()[2] << "\t";
|
---|
| 496 | break;
|
---|
[305e7e] | 497 | case TremoloKey::type :
|
---|
[4795cd] | 498 | writeEntryFromAdditionalAtomData_ifnotempty<std::string>(
|
---|
| 499 | additionalAtomData,
|
---|
| 500 | knownKeyNames,
|
---|
| 501 | defaultAdditionalData,
|
---|
| 502 | file,
|
---|
| 503 | currentAtom,
|
---|
| 504 | currentField,
|
---|
| 505 | boost::bind(&element::getSymbol, boost::bind(&AtomInfo::getType, _1)));
|
---|
[b8d4a3] | 506 | break;
|
---|
| 507 | case TremoloKey::Id :
|
---|
[47d041] | 508 | LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getId()+1);
|
---|
[812155] | 509 | *file << getLocalId(currentAtom->getId()) << "\t";
|
---|
[b8d4a3] | 510 | break;
|
---|
| 511 | case TremoloKey::neighbors :
|
---|
[47d041] | 512 | LOG(3, "Writing type " << knownKeyNames[currentField]);
|
---|
[b8d4a3] | 513 | writeNeighbors(file, atoi(it->substr(it->find("=") + 1, 1).c_str()), currentAtom);
|
---|
| 514 | break;
|
---|
[05e2ed] | 515 | case TremoloKey::imprData :
|
---|
| 516 | case TremoloKey::torsion :
|
---|
| 517 | LOG(3, "Writing type " << knownKeyNames[currentField]);
|
---|
| 518 | *file << adaptIdDependentDataString(
|
---|
| 519 | additionalAtomData[currentAtom->getId()].get(currentField),
|
---|
| 520 | idlocalizer)
|
---|
| 521 | << "\t";
|
---|
| 522 | break;
|
---|
[74a444] | 523 | case TremoloKey::resSeq :
|
---|
[4d4d33] | 524 | if (additionalAtomData.count(currentAtom->getId())) {
|
---|
[47d041] | 525 | LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << additionalAtomData[currentAtom->getId()].get(currentField));
|
---|
[74a444] | 526 | *file << additionalAtomData[currentAtom->getId()].get(currentField);
|
---|
| 527 | } else if (currentAtom->getMolecule() != NULL) {
|
---|
[47d041] | 528 | LOG(3, "Writing for type " << knownKeyNames[currentField] << " its own id: " << currentAtom->getMolecule()->getId()+1);
|
---|
[67ab71] | 529 | *file << setw(4) << currentAtom->getMolecule()->getId();
|
---|
[74a444] | 530 | } else {
|
---|
[47d041] | 531 | LOG(3, "Writing for type " << knownKeyNames[currentField] << " default value: " << defaultAdditionalData.get(currentField));
|
---|
[74a444] | 532 | *file << defaultAdditionalData.get(currentField);
|
---|
| 533 | }
|
---|
| 534 | *file << "\t";
|
---|
[4d4d33] | 535 | break;
|
---|
[2034f3] | 536 | case TremoloKey::charge :
|
---|
| 537 | if (currentAtom->getCharge() == 0.) {
|
---|
[4795cd] | 538 | writeEntryFromAdditionalAtomData_ifpresent<double>(
|
---|
| 539 | additionalAtomData,
|
---|
| 540 | knownKeyNames,
|
---|
| 541 | file,
|
---|
| 542 | currentAtom,
|
---|
| 543 | currentField,
|
---|
| 544 | boost::bind(&AtomInfo::getCharge, _1));
|
---|
[2034f3] | 545 | } else {
|
---|
| 546 | LOG(3, "Writing for type " << knownKeyNames[currentField] << " AtomInfo::charge : " << currentAtom->getCharge());
|
---|
[4795cd] | 547 | *file << currentAtom->getCharge() << "\t";
|
---|
[2034f3] | 548 | }
|
---|
| 549 | break;
|
---|
[b8d4a3] | 550 | default :
|
---|
[4795cd] | 551 | writeAdditionalAtomDataEntry<std::string>(
|
---|
| 552 | additionalAtomData,
|
---|
| 553 | knownKeyNames,
|
---|
| 554 | defaultAdditionalData,
|
---|
| 555 | file,
|
---|
| 556 | currentAtom,
|
---|
| 557 | currentField);
|
---|
[b8d4a3] | 558 | break;
|
---|
| 559 | }
|
---|
| 560 | }
|
---|
| 561 |
|
---|
[23fd43] | 562 | *file << std::endl;
|
---|
[b8d4a3] | 563 | }
|
---|
| 564 |
|
---|
| 565 | /**
|
---|
| 566 | * Writes the neighbor information of one atom to the provided stream.
|
---|
| 567 | *
|
---|
[9d83b6] | 568 | * Note that ListOfBonds of WorldTime::CurrentTime is used.
|
---|
| 569 | *
|
---|
[b8d4a3] | 570 | * \param stream where to write neighbor information to
|
---|
| 571 | * \param number of neighbors
|
---|
| 572 | * \param reference to the atom of which to take the neighbor information
|
---|
| 573 | */
|
---|
[fac58f] | 574 | void FormatParser< tremolo >::writeNeighbors(
|
---|
| 575 | std::ostream* file,
|
---|
| 576 | const int numberOfNeighbors,
|
---|
| 577 | const atom * const currentAtom) {
|
---|
[9d83b6] | 578 | const BondList& ListOfBonds = currentAtom->getListOfBonds();
|
---|
[ca2cfa] | 579 | // sort bonded indices
|
---|
| 580 | typedef std::set<atomId_t> sortedIndices;
|
---|
| 581 | sortedIndices sortedBonds;
|
---|
| 582 | for (BondList::const_iterator iter = ListOfBonds.begin();
|
---|
| 583 | iter != ListOfBonds.end(); ++iter)
|
---|
[812155] | 584 | sortedBonds.insert(getLocalId((*iter)->GetOtherAtom(currentAtom)->getId()));
|
---|
[ca2cfa] | 585 | // print indices
|
---|
| 586 | sortedIndices::const_iterator currentBond = sortedBonds.begin();
|
---|
[b8d4a3] | 587 | for (int i = 0; i < numberOfNeighbors; i++) {
|
---|
[812155] | 588 | *file << (currentBond != sortedBonds.end() ? (*currentBond) : 0) << "\t";
|
---|
[ca2cfa] | 589 | if (currentBond != sortedBonds.end())
|
---|
[0bbfa1] | 590 | ++currentBond;
|
---|
[b8d4a3] | 591 | }
|
---|
[9131f3] | 592 | }
|
---|
| 593 |
|
---|
| 594 | /**
|
---|
[23fd43] | 595 | * Stores keys from the ATOMDATA line in \a fields.
|
---|
[9131f3] | 596 | *
|
---|
| 597 | * \param line to parse the keys from
|
---|
[23fd43] | 598 | * \param offset with which offset the keys begin within the line
|
---|
| 599 | * \param fields which usedFields to use
|
---|
[9131f3] | 600 | */
|
---|
[23fd43] | 601 | void FormatParser< tremolo >::parseAtomDataKeysLine(
|
---|
| 602 | const std::string &line,
|
---|
| 603 | const int offset,
|
---|
| 604 | usedFields_t &fields) {
|
---|
[8bf9c6] | 605 | std::string keyword;
|
---|
| 606 | std::stringstream lineStream;
|
---|
[9131f3] | 607 |
|
---|
| 608 | lineStream << line.substr(offset);
|
---|
[a86cda] | 609 | lineStream >> ws;
|
---|
[9131f3] | 610 | while (lineStream.good()) {
|
---|
| 611 | lineStream >> keyword;
|
---|
[b8d4a3] | 612 | if (knownKeys[keyword.substr(0, keyword.find("="))] == TremoloKey::noKey) {
|
---|
[ecb799] | 613 | // TODO: throw exception about unknown key
|
---|
[5a667d] | 614 | cout << "Unknown key: " << keyword.substr(0, keyword.find("=")) << " is not part of the tremolo format specification." << endl;
|
---|
| 615 | throw IllegalParserKeyException();
|
---|
[4415da] | 616 | break;
|
---|
| 617 | }
|
---|
[23fd43] | 618 | fields.push_back(keyword);
|
---|
[a86cda] | 619 | lineStream >> ws;
|
---|
[9131f3] | 620 | }
|
---|
[a86cda] | 621 | LOG(2, "INFO: " << fields);
|
---|
[9131f3] | 622 | }
|
---|
| 623 |
|
---|
[5a667d] | 624 | /**
|
---|
| 625 | * Tests whether the keys from the ATOMDATA line can be read correctly.
|
---|
| 626 | *
|
---|
| 627 | * \param line to parse the keys from
|
---|
| 628 | */
|
---|
| 629 | bool FormatParser< tremolo >::testParseAtomDataKeysLine(
|
---|
| 630 | const std::string &line) {
|
---|
| 631 | std::string keyword;
|
---|
| 632 | std::stringstream lineStream;
|
---|
| 633 |
|
---|
| 634 | // check string after ATOMDATA
|
---|
| 635 | const std::string AtomData("ATOMDATA");
|
---|
| 636 | const size_t AtomDataOffset = line.find(AtomData, 0);
|
---|
| 637 | if (AtomDataOffset == std::string::npos)
|
---|
| 638 | lineStream << line;
|
---|
| 639 | else
|
---|
| 640 | lineStream << line.substr(AtomDataOffset + AtomData.length());
|
---|
| 641 | while (lineStream.good()) {
|
---|
| 642 | lineStream >> keyword;
|
---|
| 643 | //LOG(2, "DEBUG: Checking key " << keyword.substr(0, keyword.find("=")) << ".");
|
---|
| 644 | if (knownKeys[keyword.substr(0, keyword.find("="))] == TremoloKey::noKey)
|
---|
| 645 | return false;
|
---|
| 646 | }
|
---|
| 647 | //LOG(1, "INFO: " << fields);
|
---|
| 648 | return true;
|
---|
| 649 | }
|
---|
| 650 |
|
---|
[ca331c] | 651 | std::string FormatParser< tremolo >::getAtomData() const
|
---|
| 652 | {
|
---|
| 653 | std::stringstream output;
|
---|
| 654 | std::for_each(usedFields_save.begin(), usedFields_save.end(),
|
---|
| 655 | output << boost::lambda::_1 << " ");
|
---|
| 656 | const std::string returnstring(output.str());
|
---|
| 657 | return returnstring.substr(0, returnstring.find_last_of(" "));
|
---|
| 658 | }
|
---|
| 659 |
|
---|
| 660 | /** Appends the properties per atom to print to .data file by parsing line from
|
---|
| 661 | * \a atomdata_string.
|
---|
| 662 | *
|
---|
| 663 | * We just call \sa FormatParser< tremolo >::parseAtomDataKeysLine().
|
---|
| 664 | *
|
---|
| 665 | * @param atomdata_string line to parse with space-separated values
|
---|
| 666 | */
|
---|
| 667 | void FormatParser< tremolo >::setAtomData(const std::string &atomdata_string)
|
---|
| 668 | {
|
---|
| 669 | parseAtomDataKeysLine(atomdata_string, 0, usedFields_save);
|
---|
| 670 | }
|
---|
| 671 |
|
---|
[81c980b] | 672 | /** Sets the properties per atom to print to .data file by parsing line from
|
---|
| 673 | * \a atomdata_string.
|
---|
| 674 | *
|
---|
[23fd43] | 675 | * We just call \sa FormatParser< tremolo >::parseAtomDataKeysLine(), however
|
---|
| 676 | * we clear FormatParser< tremolo >::usedFields_save.
|
---|
[81c980b] | 677 | *
|
---|
| 678 | * @param atomdata_string line to parse with space-separated values
|
---|
| 679 | */
|
---|
[ca331c] | 680 | void FormatParser< tremolo >::resetAtomData(const std::string &atomdata_string)
|
---|
[81c980b] | 681 | {
|
---|
[23fd43] | 682 | usedFields_save.clear();
|
---|
| 683 | parseAtomDataKeysLine(atomdata_string, 0, usedFields_save);
|
---|
[81c980b] | 684 | }
|
---|
| 685 |
|
---|
| 686 |
|
---|
[9131f3] | 687 | /**
|
---|
| 688 | * Reads one data line of a tremolo file and interprets it according to the keys
|
---|
| 689 | * obtained from the ATOMDATA line.
|
---|
| 690 | *
|
---|
| 691 | * \param line to parse as an atom
|
---|
[dc1d9e] | 692 | * \param *newmol molecule to add atom to
|
---|
[9131f3] | 693 | */
|
---|
[23fd43] | 694 | void FormatParser< tremolo >::readAtomDataLine(const std::string &line, molecule *newmol = NULL) {
|
---|
[8bf9c6] | 695 | std::stringstream lineStream;
|
---|
[4415da] | 696 | atom* newAtom = World::getInstance().createAtom();
|
---|
[89a31d] | 697 | const atomId_t atomid = newAtom->getId();
|
---|
| 698 | additionalAtomData[atomid] = TremoloAtomInfoContainer(); // fill with default values
|
---|
| 699 | TremoloAtomInfoContainer *atomInfo = &additionalAtomData[atomid];
|
---|
[b8d4a3] | 700 | TremoloKey::atomDataKey currentField;
|
---|
[72d108] | 701 | ConvertTo<double> toDouble;
|
---|
| 702 | ConvertTo<int> toInt;
|
---|
[056e70] | 703 | Vector tempVector;
|
---|
[72d108] | 704 |
|
---|
| 705 | // setup tokenizer, splitting up white-spaced entries
|
---|
| 706 | typedef boost::tokenizer<boost::char_separator<char> >
|
---|
| 707 | tokenizer;
|
---|
| 708 | boost::char_separator<char> whitespacesep(" \t");
|
---|
| 709 | tokenizer tokens(line, whitespacesep);
|
---|
| 710 | ASSERT(tokens.begin() != tokens.end(),
|
---|
[765f16] | 711 | "FormatParser< tremolo >::readAtomDataLine - empty string, need at least ' '!");
|
---|
[fc41df] | 712 | tokenizer::const_iterator tok_iter = tokens.begin();
|
---|
[72d108] | 713 | // then associate each token to each file
|
---|
[fc41df] | 714 | for (usedFields_t::const_iterator it = usedFields_load.begin(); it != usedFields_load.end(); it++) {
|
---|
[72d108] | 715 | const std::string keyName = it->substr(0, it->find("="));
|
---|
| 716 | currentField = knownKeys[keyName];
|
---|
[fc41df] | 717 | ASSERT(tok_iter != tokens.end(),
|
---|
| 718 | "FormatParser< tremolo >::readAtomDataLine - too few entries in line '"+line+"'!");
|
---|
| 719 | const std::string &word = *tok_iter;
|
---|
[47d041] | 720 | LOG(4, "INFO: Parsing key " << keyName << " with remaining data " << word);
|
---|
[4415da] | 721 | switch (currentField) {
|
---|
[b8d4a3] | 722 | case TremoloKey::x :
|
---|
[4415da] | 723 | // for the moment, assume there are always three dimensions
|
---|
[d74077] | 724 | for (int i=0;i<NDIM;i++) {
|
---|
[765f16] | 725 | ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for x["+toString(i)+"]!");
|
---|
[fc41df] | 726 | LOG(4, "INFO: Parsing key " << keyName << " with next token " << word);
|
---|
| 727 | newAtom->set(i, toDouble(word));
|
---|
[72d108] | 728 | tok_iter++;
|
---|
[d74077] | 729 | }
|
---|
[4415da] | 730 | break;
|
---|
[b8d4a3] | 731 | case TremoloKey::u :
|
---|
[4415da] | 732 | // for the moment, assume there are always three dimensions
|
---|
[72d108] | 733 | for (int i=0;i<NDIM;i++) {
|
---|
[765f16] | 734 | ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for u["+toString(i)+"]!");
|
---|
[fc41df] | 735 | LOG(4, "INFO: Parsing key " << keyName << " with next token " << word);
|
---|
| 736 | tempVector[i] = toDouble(word);
|
---|
[72d108] | 737 | tok_iter++;
|
---|
| 738 | }
|
---|
[056e70] | 739 | newAtom->setAtomicVelocity(tempVector);
|
---|
[4415da] | 740 | break;
|
---|
[e6e4a0] | 741 | case TremoloKey::F :
|
---|
| 742 | // for the moment, assume there are always three dimensions
|
---|
| 743 | for (int i=0;i<NDIM;i++) {
|
---|
| 744 | ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for F["+toString(i)+"]!");
|
---|
[fc41df] | 745 | LOG(4, "INFO: Parsing key " << keyName << " with next token " << word);
|
---|
| 746 | tempVector[i] = toDouble(word);
|
---|
[e6e4a0] | 747 | tok_iter++;
|
---|
| 748 | }
|
---|
| 749 | newAtom->setAtomicForce(tempVector);
|
---|
| 750 | break;
|
---|
[305e7e] | 751 | case TremoloKey::type :
|
---|
[4d4d33] | 752 | {
|
---|
[765f16] | 753 | ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
|
---|
[fc41df] | 754 | LOG(4, "INFO: Parsing key " << keyName << " with next token " << word);
|
---|
[a275b3] | 755 | std::string element;
|
---|
| 756 | try {
|
---|
[fc41df] | 757 | element = knownTypes.getType(word);
|
---|
[a275b3] | 758 | } catch(IllegalParserKeyException) {
|
---|
| 759 | // clean up
|
---|
| 760 | World::getInstance().destroyAtom(newAtom);
|
---|
| 761 | // give an error
|
---|
[fc41df] | 762 | ELOG(0, "TremoloParser: I do not understand the element token " << word << ".");
|
---|
| 763 | return;
|
---|
[a275b3] | 764 | }
|
---|
[4d4d33] | 765 | // put type name into container for later use
|
---|
[fc41df] | 766 | atomInfo->set(currentField, word);
|
---|
| 767 | LOG(4, "INFO: Parsing element " << (word) << " as " << element << " according to KnownTypes.");
|
---|
[72d108] | 768 | tok_iter++;
|
---|
[4d4d33] | 769 | newAtom->setType(World::getInstance().getPeriode()->FindElement(element));
|
---|
[b8d4a3] | 770 | ASSERT(newAtom->getType(), "Type was not set for this atom");
|
---|
[4415da] | 771 | break;
|
---|
[4d4d33] | 772 | }
|
---|
[b8d4a3] | 773 | case TremoloKey::Id :
|
---|
[765f16] | 774 | ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
|
---|
[fc41df] | 775 | LOG(4, "INFO: Parsing key " << keyName << " with next token " << word);
|
---|
| 776 | associateLocaltoGlobalId(toInt(word), atomid);
|
---|
[72d108] | 777 | tok_iter++;
|
---|
[4415da] | 778 | break;
|
---|
[b8d4a3] | 779 | case TremoloKey::neighbors :
|
---|
[72d108] | 780 | for (int i=0;i<atoi(it->substr(it->find("=") + 1, 1).c_str());i++) {
|
---|
[765f16] | 781 | ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
|
---|
[fc41df] | 782 | LOG(4, "INFO: Parsing key " << keyName << " with next token " << word);
|
---|
| 783 | lineStream << word << "\t";
|
---|
[72d108] | 784 | tok_iter++;
|
---|
| 785 | }
|
---|
[b8d4a3] | 786 | readNeighbors(&lineStream,
|
---|
[89a31d] | 787 | atoi(it->substr(it->find("=") + 1, 1).c_str()), atomid);
|
---|
[9131f3] | 788 | break;
|
---|
[2034f3] | 789 | case TremoloKey::charge :
|
---|
| 790 | ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
|
---|
[fc41df] | 791 | LOG(4, "INFO: Parsing key " << keyName << " with next token " << word);
|
---|
| 792 | atomInfo->set(currentField, word);
|
---|
| 793 | newAtom->setCharge(boost::lexical_cast<double>(word));
|
---|
[2034f3] | 794 | tok_iter++;
|
---|
| 795 | break;
|
---|
[9131f3] | 796 | default :
|
---|
[765f16] | 797 | ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
|
---|
[fc41df] | 798 | LOG(4, "INFO: Parsing key " << keyName << " with next token " << word);
|
---|
| 799 | atomInfo->set(currentField, word);
|
---|
[72d108] | 800 | tok_iter++;
|
---|
[9131f3] | 801 | break;
|
---|
| 802 | }
|
---|
| 803 | }
|
---|
[89a31d] | 804 | LOG(3, "INFO: Parsed atom " << atomid << ".");
|
---|
| 805 | if (newmol != NULL)
|
---|
[dc1d9e] | 806 | newmol->AddAtom(newAtom);
|
---|
[6bc51d] | 807 | }
|
---|
[9131f3] | 808 |
|
---|
[99db9b] | 809 | bool FormatParser< tremolo >::saveAtomsInExttypes(
|
---|
| 810 | std::ostream &output,
|
---|
| 811 | const std::vector<const atom*> &atoms,
|
---|
| 812 | const int id) const
|
---|
[531f27] | 813 | {
|
---|
| 814 | bool status = true;
|
---|
| 815 | // parse the file
|
---|
[99db9b] | 816 | for (std::vector<const atom *>::const_iterator iter = atoms.begin();
|
---|
[531f27] | 817 | iter != atoms.end(); ++iter) {
|
---|
| 818 | const int atomicid = getLocalId((*iter)->getId());
|
---|
| 819 | if (atomicid == -1)
|
---|
| 820 | status = false;
|
---|
| 821 | output << atomicid << "\t" << id << std::endl;
|
---|
| 822 | }
|
---|
| 823 |
|
---|
| 824 | return status;
|
---|
| 825 | }
|
---|
| 826 |
|
---|
[b8d4a3] | 827 | /**
|
---|
| 828 | * Reads neighbor information for one atom from the input.
|
---|
| 829 | *
|
---|
[0bbfa1] | 830 | * \param line stream where to read the information from
|
---|
| 831 | * \param numberOfNeighbors number of neighbors to read
|
---|
| 832 | * \param atomid world id of the atom the information belongs to
|
---|
[b8d4a3] | 833 | */
|
---|
[fac58f] | 834 | void FormatParser< tremolo >::readNeighbors(
|
---|
| 835 | std::stringstream* line,
|
---|
| 836 | const int numberOfNeighbors,
|
---|
| 837 | const int atomId) {
|
---|
[b8d4a3] | 838 | int neighborId = 0;
|
---|
| 839 | for (int i = 0; i < numberOfNeighbors; i++) {
|
---|
| 840 | *line >> neighborId;
|
---|
| 841 | // 0 is used to fill empty neighbor positions in the tremolo file.
|
---|
| 842 | if (neighborId > 0) {
|
---|
[47d041] | 843 | LOG(4, "INFO: Atom with global id " << atomId
|
---|
| 844 | << " has neighbour with serial " << neighborId);
|
---|
[b8d4a3] | 845 | additionalAtomData[atomId].neighbors.push_back(neighborId);
|
---|
| 846 | }
|
---|
| 847 | }
|
---|
| 848 | }
|
---|
[9131f3] | 849 |
|
---|
| 850 | /**
|
---|
[23fd43] | 851 | * Checks whether the provided name is within \a fields.
|
---|
[b8d4a3] | 852 | *
|
---|
[23fd43] | 853 | * \param fields which usedFields to use
|
---|
| 854 | * \param fieldName name to check
|
---|
[b8d4a3] | 855 | * \return true if the field name is used
|
---|
[9131f3] | 856 | */
|
---|
[fac58f] | 857 | bool FormatParser< tremolo >::isUsedField(
|
---|
| 858 | const usedFields_t &fields,
|
---|
| 859 | const std::string &fieldName) const
|
---|
[23fd43] | 860 | {
|
---|
[b8d4a3] | 861 | bool fieldNameExists = false;
|
---|
[23fd43] | 862 | for (usedFields_t::const_iterator usedField = fields.begin();
|
---|
| 863 | usedField != fields.end(); usedField++) {
|
---|
[b8d4a3] | 864 | if (usedField->substr(0, usedField->find("=")) == fieldName)
|
---|
| 865 | fieldNameExists = true;
|
---|
| 866 | }
|
---|
[9131f3] | 867 |
|
---|
[b8d4a3] | 868 | return fieldNameExists;
|
---|
| 869 | }
|
---|
| 870 |
|
---|
| 871 |
|
---|
| 872 | /**
|
---|
| 873 | * Adds the collected neighbor information to the atoms in the world. The atoms
|
---|
| 874 | * are found by their current ID and mapped to the corresponding atoms with the
|
---|
| 875 | * Id found in the parsed file.
|
---|
[9f8b01] | 876 | *
|
---|
| 877 | * @param atoms vector with all newly added (global) atomic ids
|
---|
[b8d4a3] | 878 | */
|
---|
[fac58f] | 879 | void FormatParser< tremolo >::processNeighborInformation(
|
---|
| 880 | const std::vector<atomId_t> &atoms) {
|
---|
[23fd43] | 881 | if (!isUsedField(usedFields_load, "neighbors")) {
|
---|
[b8d4a3] | 882 | return;
|
---|
| 883 | }
|
---|
| 884 |
|
---|
[9f8b01] | 885 | for (std::vector<atomId_t>::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
|
---|
| 886 | ASSERT(additionalAtomData.count(*iter) != 0,
|
---|
| 887 | "FormatParser< tremolo >::processNeighborInformation() - global id "
|
---|
| 888 | +toString(*iter)+" unknown in additionalAtomData.");
|
---|
| 889 | TremoloAtomInfoContainer ¤tInfo = additionalAtomData[*iter];
|
---|
| 890 | ASSERT (!currentInfo.neighbors_processed,
|
---|
| 891 | "FormatParser< tremolo >::processNeighborInformation() - neighbors of new atom "
|
---|
| 892 | +toString(*iter)+" are already processed.");
|
---|
| 893 | for(std::vector<int>::const_iterator neighbor = currentInfo.neighbors.begin();
|
---|
| 894 | neighbor != currentInfo.neighbors.end(); neighbor++
|
---|
| 895 | ) {
|
---|
| 896 | LOG(3, "INFO: Creating bond between ("
|
---|
| 897 | << *iter
|
---|
| 898 | << ") and ("
|
---|
| 899 | << getGlobalId(*neighbor) << "|" << *neighbor << ")");
|
---|
| 900 | ASSERT(getGlobalId(*neighbor) != -1,
|
---|
| 901 | "FormatParser< tremolo >::processNeighborInformation() - global id to local id "
|
---|
| 902 | +toString(*neighbor)+" is unknown.");
|
---|
| 903 | World::getInstance().getAtom(AtomById(*iter))
|
---|
| 904 | ->addBond(WorldTime::getTime(), World::getInstance().getAtom(AtomById(getGlobalId(*neighbor))));
|
---|
[9131f3] | 905 | }
|
---|
[9f8b01] | 906 | currentInfo.neighbors_processed = true;
|
---|
[9131f3] | 907 | }
|
---|
[6bc51d] | 908 | }
|
---|
| 909 |
|
---|
[9131f3] | 910 | /**
|
---|
[b8d4a3] | 911 | * Replaces atom IDs read from the file by the corresponding world IDs. All IDs
|
---|
| 912 | * IDs of the input string will be replaced; expected separating characters are
|
---|
| 913 | * "-" and ",".
|
---|
[9131f3] | 914 | *
|
---|
[b8d4a3] | 915 | * \param string in which atom IDs should be adapted
|
---|
[05e2ed] | 916 | * \param idgetter function pointer to change the id
|
---|
[b8d4a3] | 917 | *
|
---|
| 918 | * \return input string with modified atom IDs
|
---|
[9131f3] | 919 | */
|
---|
[05e2ed] | 920 | std::string FormatParser< tremolo >::adaptIdDependentDataString(
|
---|
| 921 | const std::string &data,
|
---|
| 922 | const boost::function<int (const int)> &idgetter
|
---|
| 923 | ) {
|
---|
[b8d4a3] | 924 | // there might be no IDs
|
---|
| 925 | if (data == "-") {
|
---|
| 926 | return "-";
|
---|
| 927 | }
|
---|
| 928 |
|
---|
| 929 | char separator;
|
---|
| 930 | int id;
|
---|
[8bf9c6] | 931 | std::stringstream line, result;
|
---|
[b8d4a3] | 932 | line << data;
|
---|
| 933 |
|
---|
| 934 | line >> id;
|
---|
[05e2ed] | 935 | result << idgetter(id);
|
---|
[b8d4a3] | 936 | while (line.good()) {
|
---|
| 937 | line >> separator >> id;
|
---|
[05e2ed] | 938 | result << separator << idgetter(id);
|
---|
[b8d4a3] | 939 | }
|
---|
| 940 |
|
---|
| 941 | return result.str();
|
---|
[6bc51d] | 942 | }
|
---|
[b8d4a3] | 943 |
|
---|
[05e2ed] | 944 | /** Corrects the atom IDs in each imprData entry to the corresponding world IDs
|
---|
[b8d4a3] | 945 | * as they might differ from the originally read IDs.
|
---|
[05e2ed] | 946 | *
|
---|
| 947 | * \param atoms currently parsed in atoms
|
---|
[b8d4a3] | 948 | */
|
---|
[05e2ed] | 949 | void FormatParser< tremolo >::adaptImprData(const std::vector<atomId_t> &atoms) {
|
---|
[23fd43] | 950 | if (!isUsedField(usedFields_load, "imprData")) {
|
---|
[b8d4a3] | 951 | return;
|
---|
| 952 | }
|
---|
| 953 |
|
---|
[05e2ed] | 954 | for (std::vector<atomId_t>::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
|
---|
| 955 | ASSERT(additionalAtomData.count(*iter) != 0,
|
---|
| 956 | "FormatParser< tremolo >::processNeighborInformation() - global id "
|
---|
| 957 | +toString(*iter)+" unknown in additionalAtomData.");
|
---|
| 958 | TremoloAtomInfoContainer ¤tInfo = additionalAtomData[*iter];
|
---|
| 959 | currentInfo.imprData = adaptIdDependentDataString(currentInfo.imprData, idglobalizer);
|
---|
[b8d4a3] | 960 | }
|
---|
[6bc51d] | 961 | }
|
---|
[4415da] | 962 |
|
---|
[05e2ed] | 963 | /** Corrects the atom IDs in each torsion entry to the corresponding world IDs
|
---|
[b8d4a3] | 964 | * as they might differ from the originally read IDs.
|
---|
[05e2ed] | 965 | *
|
---|
| 966 | * \param atoms currently parsed in atoms
|
---|
[b8d4a3] | 967 | */
|
---|
[05e2ed] | 968 | void FormatParser< tremolo >::adaptTorsion(const std::vector<atomId_t> &atoms) {
|
---|
[23fd43] | 969 | if (!isUsedField(usedFields_load, "torsion")) {
|
---|
[b8d4a3] | 970 | return;
|
---|
| 971 | }
|
---|
| 972 |
|
---|
[05e2ed] | 973 | for (std::vector<atomId_t>::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
|
---|
| 974 | ASSERT(additionalAtomData.count(*iter) != 0,
|
---|
| 975 | "FormatParser< tremolo >::processNeighborInformation() - global id "
|
---|
| 976 | +toString(*iter)+" unknown in additionalAtomData.");
|
---|
| 977 | TremoloAtomInfoContainer ¤tInfo = additionalAtomData[*iter];
|
---|
| 978 | currentInfo.torsion = adaptIdDependentDataString(currentInfo.torsion, idglobalizer);
|
---|
[b8d4a3] | 979 | }
|
---|
| 980 | }
|
---|
| 981 |
|
---|