[bcf653] | 1 | /*
|
---|
| 2 | * Project: MoleCuilder
|
---|
| 3 | * Description: creates and alters molecular systems
|
---|
[0aa122] | 4 | * Copyright (C) 2010-2012 University of Bonn. All rights reserved.
|
---|
[94d5ac6] | 5 | *
|
---|
| 6 | *
|
---|
| 7 | * This file is part of MoleCuilder.
|
---|
| 8 | *
|
---|
| 9 | * MoleCuilder is free software: you can redistribute it and/or modify
|
---|
| 10 | * it under the terms of the GNU General Public License as published by
|
---|
| 11 | * the Free Software Foundation, either version 2 of the License, or
|
---|
| 12 | * (at your option) any later version.
|
---|
| 13 | *
|
---|
| 14 | * MoleCuilder is distributed in the hope that it will be useful,
|
---|
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
| 17 | * GNU General Public License for more details.
|
---|
| 18 | *
|
---|
| 19 | * You should have received a copy of the GNU General Public License
|
---|
| 20 | * along with MoleCuilder. If not, see <http://www.gnu.org/licenses/>.
|
---|
[bcf653] | 21 | */
|
---|
| 22 |
|
---|
[97ebf8] | 23 | /*
|
---|
| 24 | * CenterOnEdgeAction.cpp
|
---|
| 25 | *
|
---|
| 26 | * Created on: May 8, 2010
|
---|
| 27 | * Author: heber
|
---|
| 28 | */
|
---|
| 29 |
|
---|
[bf3817] | 30 | // include config.h
|
---|
| 31 | #ifdef HAVE_CONFIG_H
|
---|
| 32 | #include <config.h>
|
---|
| 33 | #endif
|
---|
| 34 |
|
---|
[de7d1d] | 35 | // include headers that implement a archive in simple text format
|
---|
| 36 | #include <boost/archive/text_oarchive.hpp>
|
---|
| 37 | #include <boost/archive/text_iarchive.hpp>
|
---|
| 38 | #include "boost/serialization/vector.hpp"
|
---|
| 39 |
|
---|
[ad011c] | 40 | #include "CodePatterns/MemDebug.hpp"
|
---|
[112b09] | 41 |
|
---|
[6f0841] | 42 | #include "Atom/atom.hpp"
|
---|
[ad011c] | 43 | #include "CodePatterns/Log.hpp"
|
---|
[de7d1d] | 44 | #include "LinearAlgebra/MatrixContent.hpp"
|
---|
| 45 | #include "LinearAlgebra/RealSpaceMatrix.hpp"
|
---|
[57f243] | 46 | #include "LinearAlgebra/Vector.hpp"
|
---|
[de7d1d] | 47 | #include "molecule.hpp"
|
---|
[97ebf8] | 48 | #include "World.hpp"
|
---|
| 49 |
|
---|
| 50 | #include <iostream>
|
---|
| 51 | #include <string>
|
---|
[de7d1d] | 52 | #include <vector>
|
---|
[97ebf8] | 53 |
|
---|
[1fd675] | 54 | #include "Actions/WorldAction/CenterOnEdgeAction.hpp"
|
---|
[1ba67d] | 55 |
|
---|
[ce7fdc] | 56 | using namespace MoleCuilder;
|
---|
| 57 |
|
---|
[1fd675] | 58 | // and construct the stuff
|
---|
| 59 | #include "CenterOnEdgeAction.def"
|
---|
| 60 | #include "Action_impl_pre.hpp"
|
---|
| 61 | /** =========== define the function ====================== */
|
---|
[1ba67d] | 62 | Action::state_ptr WorldCenterOnEdgeAction::performCall() {
|
---|
[97ebf8] | 63 | Vector Min;
|
---|
| 64 | Vector Max;
|
---|
| 65 |
|
---|
[de7d1d] | 66 | // create undo state
|
---|
| 67 | std::stringstream undostream;
|
---|
| 68 | boost::archive::text_oarchive oa(undostream);
|
---|
| 69 | const RealSpaceMatrix &matrix = World::getInstance().getDomain().getM();
|
---|
| 70 | oa << matrix;
|
---|
| 71 | std::vector< boost::shared_ptr<Vector> > OldPositions;
|
---|
| 72 | std::vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
|
---|
| 73 | for (std::vector<atom *>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner)
|
---|
| 74 | OldPositions.push_back(
|
---|
| 75 | boost::shared_ptr<Vector>(new Vector(
|
---|
| 76 | (*AtomRunner)->getPosition()
|
---|
| 77 | ))
|
---|
| 78 | );
|
---|
| 79 |
|
---|
[1ba67d] | 80 | // get maximum and minimum
|
---|
| 81 | ASSERT(AllAtoms.size() > 0, "For CenteronEdge atoms must be present.");
|
---|
[de7d1d] | 82 | std::vector<atom *>::iterator AtomRunner = AllAtoms.begin();
|
---|
[d74077] | 83 | Min = (*AtomRunner)->getPosition();
|
---|
| 84 | Max = (*AtomRunner)->getPosition();
|
---|
[1ba67d] | 85 | for (; AtomRunner != AllAtoms.end(); ++AtomRunner) {
|
---|
[97ebf8] | 86 | for (int i=0;i<NDIM;i++) {
|
---|
[d74077] | 87 | if ((*AtomRunner)->at(i) > Max[i])
|
---|
| 88 | Max[i] = (*AtomRunner)->at(i);
|
---|
| 89 | if ((*AtomRunner)->at(i) < Min[i])
|
---|
| 90 | Min[i] = (*AtomRunner)->at(i);
|
---|
[97ebf8] | 91 | }
|
---|
| 92 | }
|
---|
[1ba67d] | 93 | // set new box size
|
---|
[cca9ef] | 94 | RealSpaceMatrix domain;
|
---|
[1ba67d] | 95 | for (int i=0;i<NDIM;i++) {
|
---|
| 96 | double tmp = Max[i]-Min[i];
|
---|
| 97 | tmp = fabs(tmp)>=1. ? tmp : 1.0;
|
---|
| 98 | domain.at(i,i) = tmp;
|
---|
| 99 | }
|
---|
| 100 | World::getInstance().setDomain(domain);
|
---|
| 101 | // translate all atoms, such that Min is aty (0,0,0)
|
---|
[de7d1d] | 102 | for (std::vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner)
|
---|
[d74077] | 103 | *(*AtomRunner) -= Min;
|
---|
[1ba67d] | 104 |
|
---|
[3bd460a] | 105 | // give final box size
|
---|
| 106 | LOG(0, "Box domain is now " << World::getInstance().getDomain().getM());
|
---|
| 107 |
|
---|
[de7d1d] | 108 | // create undo state
|
---|
| 109 | WorldCenterOnEdgeState *UndoState =
|
---|
| 110 | new WorldCenterOnEdgeState(
|
---|
| 111 | undostream.str(),
|
---|
| 112 | Min,
|
---|
| 113 | Max,
|
---|
| 114 | params
|
---|
| 115 | );
|
---|
| 116 |
|
---|
| 117 | return Action::state_ptr(UndoState);
|
---|
[97ebf8] | 118 | }
|
---|
| 119 |
|
---|
| 120 | Action::state_ptr WorldCenterOnEdgeAction::performUndo(Action::state_ptr _state) {
|
---|
[de7d1d] | 121 | WorldCenterOnEdgeState *state = assert_cast<WorldCenterOnEdgeState*>(_state.get());
|
---|
| 122 |
|
---|
| 123 | // restore domain
|
---|
| 124 | RealSpaceMatrix matrix;
|
---|
| 125 | std::stringstream undostream(state->undostring);
|
---|
| 126 | boost::archive::text_iarchive ia(undostream);
|
---|
| 127 | ia >> matrix;
|
---|
| 128 | World::getInstance().setDomain(matrix);
|
---|
| 129 |
|
---|
| 130 | // translate all atoms back
|
---|
| 131 | std::vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
|
---|
| 132 | for (vector<atom*>::iterator AtomRunner = AllAtoms.begin();
|
---|
| 133 | AtomRunner != AllAtoms.end();
|
---|
| 134 | ++AtomRunner)
|
---|
| 135 | *(*AtomRunner) += state->Min;
|
---|
| 136 |
|
---|
| 137 | // give final box size
|
---|
| 138 | LOG(0, "Box domain restored to " << World::getInstance().getDomain().getM());
|
---|
[97ebf8] | 139 |
|
---|
[de7d1d] | 140 | return Action::state_ptr(_state);
|
---|
[97ebf8] | 141 | }
|
---|
| 142 |
|
---|
| 143 | Action::state_ptr WorldCenterOnEdgeAction::performRedo(Action::state_ptr _state){
|
---|
[de7d1d] | 144 | WorldCenterOnEdgeState *state = assert_cast<WorldCenterOnEdgeState*>(_state.get());
|
---|
| 145 |
|
---|
| 146 | // set new box size
|
---|
| 147 | RealSpaceMatrix rmatrix;
|
---|
| 148 | for (int i=0;i<NDIM;i++) {
|
---|
| 149 | double tmp = state->Max[i]-state->Min[i];
|
---|
| 150 | tmp = fabs(tmp)>=1. ? tmp : 1.0;
|
---|
| 151 | rmatrix.at(i,i) = tmp;
|
---|
| 152 | }
|
---|
| 153 | World::getInstance().setDomain(rmatrix);
|
---|
| 154 | // translate all atoms, such that Min is aty (0,0,0)
|
---|
| 155 | std::vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
|
---|
| 156 | for (vector<atom*>::iterator AtomRunner = AllAtoms.begin();
|
---|
| 157 | AtomRunner != AllAtoms.end();
|
---|
| 158 | ++AtomRunner)
|
---|
| 159 | *(*AtomRunner) -= state->Min;
|
---|
| 160 |
|
---|
| 161 | // give final box size
|
---|
| 162 | LOG(0, "Box domain is again " << World::getInstance().getDomain().getM());
|
---|
| 163 |
|
---|
| 164 | return Action::state_ptr(_state);
|
---|
[97ebf8] | 165 | }
|
---|
| 166 |
|
---|
| 167 | bool WorldCenterOnEdgeAction::canUndo() {
|
---|
[de7d1d] | 168 | return true;
|
---|
[97ebf8] | 169 | }
|
---|
| 170 |
|
---|
| 171 | bool WorldCenterOnEdgeAction::shouldUndo() {
|
---|
[de7d1d] | 172 | return true;
|
---|
[97ebf8] | 173 | }
|
---|
[1fd675] | 174 | /** =========== end of function ====================== */
|
---|