[2fcef3] | 1 | /*
|
---|
| 2 | * Project: MoleCuilder
|
---|
| 3 | * Description: creates and alters molecular systems
|
---|
| 4 | * Copyright (C) 2015 Frederik Heber. All rights reserved.
|
---|
| 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/>.
|
---|
| 21 | */
|
---|
| 22 |
|
---|
| 23 | /*
|
---|
| 24 | * SaturateAction.cpp
|
---|
| 25 | *
|
---|
| 26 | * Created on: Jan 26, 2015
|
---|
| 27 | * Author: heber
|
---|
| 28 | */
|
---|
| 29 |
|
---|
| 30 | // include config.h
|
---|
| 31 | #ifdef HAVE_CONFIG_H
|
---|
| 32 | #include <config.h>
|
---|
| 33 | #endif
|
---|
| 34 |
|
---|
[9eb71b3] | 35 | //#include "CodePatterns/MemDebug.hpp"
|
---|
[2fcef3] | 36 |
|
---|
| 37 | #include "CodePatterns/Log.hpp"
|
---|
| 38 |
|
---|
| 39 | #include "Actions/AtomAction/SaturateAction.hpp"
|
---|
| 40 | #include "Actions/UndoRedoHelpers.hpp"
|
---|
| 41 | #include "Atom/atom.hpp"
|
---|
| 42 | #include "Atom/AtomicInfo.hpp"
|
---|
| 43 | #include "Element/element.hpp"
|
---|
| 44 | #include "Element/periodentafel.hpp"
|
---|
| 45 | #include "Fragmentation/Exporters/SphericalPointDistribution.hpp"
|
---|
| 46 | #include "molecule.hpp"
|
---|
| 47 | #include "World.hpp"
|
---|
| 48 | #include "WorldTime.hpp"
|
---|
| 49 |
|
---|
| 50 | using namespace MoleCuilder;
|
---|
| 51 |
|
---|
| 52 | // and construct the stuff
|
---|
| 53 | #include "SaturateAction.def"
|
---|
| 54 | #include "Action_impl_pre.hpp"
|
---|
| 55 | /** =========== define the function ====================== */
|
---|
| 56 | ActionState::ptr AtomSaturateAction::performCall() {
|
---|
| 57 |
|
---|
| 58 | // get hydrogen element
|
---|
| 59 | const element * const hydrogen = World::getInstance().getPeriode()->FindElement(1);
|
---|
| 60 |
|
---|
| 61 | // go through each atom
|
---|
| 62 | std::vector<AtomicInfo> addedHydrogens;
|
---|
| 63 | World &world = World::getInstance();
|
---|
| 64 | for (World::AtomSelectionIterator iter = world.beginAtomSelection();
|
---|
| 65 | iter != world.endAtomSelection(); ++iter) {
|
---|
| 66 | atom * const _atom = iter->second;
|
---|
| 67 |
|
---|
| 68 | // if atom is attached to molecule, add hydrogens there, too
|
---|
[270bdf] | 69 | molecule * mol = NULL;
|
---|
| 70 | if (_atom->getMolecule() == NULL) {
|
---|
[2fcef3] | 71 | mol = World::getInstance().createMolecule();
|
---|
| 72 | mol->AddAtom(_atom);
|
---|
[270bdf] | 73 | } else {
|
---|
| 74 | mol = World::getInstance().getMolecule(MoleculeById(_atom->getMolecule()->getId()));
|
---|
[2fcef3] | 75 | }
|
---|
[270bdf] | 76 | ASSERT( mol != NULL,
|
---|
[0c42f2] | 77 | "AtomSaturateAction::performCall() - mol is still NULL." );
|
---|
| 78 |
|
---|
| 79 | // radius of polygon on sphere
|
---|
| 80 | double typical_distance = _atom->getType()->getHBondDistance(0);
|
---|
| 81 | if (typical_distance == -1.)
|
---|
| 82 | typical_distance = 1.;
|
---|
| 83 |
|
---|
| 84 | // check for any bonds and get vacant positions
|
---|
| 85 | SphericalPointDistribution::Polygon_t vacant_positions;
|
---|
[3dadd5] | 86 | const BondList& ListOfBonds = _atom->getListOfBonds();
|
---|
| 87 | SphericalPointDistribution PointSphere(typical_distance);
|
---|
| 88 | if (ListOfBonds.size() == 0) {
|
---|
| 89 | vacant_positions = PointSphere.getSimplePolygon(_atom->getType()->getNoValenceOrbitals());
|
---|
| 90 | LOG(3, "DEBUG: Using ideal positions as " << vacant_positions);
|
---|
| 91 | } else {
|
---|
| 92 | // get ideal polygon and currently occupied positions
|
---|
| 93 | const SphericalPointDistribution::Polygon_t ideal_positions =
|
---|
| 94 | PointSphere.getSimplePolygon(_atom->getType()->getNoValenceOrbitals());
|
---|
| 95 | LOG(3, "DEBUG: ideal positions are " << ideal_positions);
|
---|
| 96 | SphericalPointDistribution::WeightedPolygon_t current_positions;
|
---|
| 97 | for (BondList::const_iterator bonditer = ListOfBonds.begin();
|
---|
| 98 | bonditer != ListOfBonds.end(); ++bonditer) {
|
---|
| 99 | const Vector position =
|
---|
| 100 | (*bonditer)->GetOtherAtom(_atom)->getPosition().getVectorToPoint(_atom->getPosition());
|
---|
| 101 | current_positions.push_back(
|
---|
| 102 | std::make_pair( (1./position.Norm())*position, (*bonditer)->getDegree() ));
|
---|
| 103 | }
|
---|
| 104 | LOG(3, "DEBUG: current occupied positions are " << current_positions);
|
---|
| 105 |
|
---|
| 106 | // find the best matching rotated polygon
|
---|
| 107 | vacant_positions = PointSphere.getRemainingPoints(
|
---|
| 108 | current_positions,
|
---|
| 109 | _atom->getType()->getNoValenceOrbitals());
|
---|
| 110 | LOG(3, "DEBUG: Resulting vacant positions are " << vacant_positions);
|
---|
| 111 |
|
---|
| 112 | // scale vacant positions to typical_distance
|
---|
| 113 | std::for_each(
|
---|
| 114 | vacant_positions.begin(), vacant_positions.end(),
|
---|
| 115 | boost::bind(&Vector::Scale, _1, boost::cref(typical_distance)));
|
---|
| 116 | LOG(3, "DEBUG: Rescaled vacant positions are " << vacant_positions);
|
---|
| 117 | }
|
---|
[0c42f2] | 118 |
|
---|
| 119 | // add the hydrogens
|
---|
| 120 | const Vector AtomsPosition = _atom->getPosition();
|
---|
| 121 | for (SphericalPointDistribution::Polygon_t::const_iterator iter = vacant_positions.begin();
|
---|
| 122 | iter != vacant_positions.end(); ++iter) {
|
---|
| 123 | // for every Vector add a point relative to atom's position
|
---|
| 124 | atom * hydrogenAtom = World::getInstance().createAtom();
|
---|
| 125 | hydrogenAtom->setType(hydrogen);
|
---|
| 126 | hydrogenAtom->setPosition(AtomsPosition + *iter);
|
---|
| 127 | mol->AddAtom(hydrogenAtom);
|
---|
| 128 | // add bond
|
---|
| 129 | _atom->addBond(WorldTime::getTime(), hydrogenAtom);
|
---|
| 130 | // mark down for undo state
|
---|
| 131 | addedHydrogens.push_back(AtomicInfo(*(hydrogenAtom)));
|
---|
| 132 | }
|
---|
[2fcef3] | 133 | }
|
---|
| 134 |
|
---|
| 135 | return ActionState::ptr(new AtomSaturateState(addedHydrogens, params));
|
---|
| 136 | }
|
---|
| 137 |
|
---|
| 138 | ActionState::ptr AtomSaturateAction::performUndo(ActionState::ptr _state) {
|
---|
| 139 | AtomSaturateState *state = assert_cast<AtomSaturateState*>(_state.get());
|
---|
| 140 |
|
---|
| 141 | // remove all added hydrogen atoms
|
---|
| 142 | RemoveAtomsFromAtomicInfo(state->addedHydrogens);
|
---|
| 143 |
|
---|
| 144 | return ActionState::ptr(_state);
|
---|
| 145 | }
|
---|
| 146 |
|
---|
| 147 | ActionState::ptr AtomSaturateAction::performRedo(ActionState::ptr _state){
|
---|
| 148 | AtomSaturateState *state = assert_cast<AtomSaturateState*>(_state.get());
|
---|
| 149 |
|
---|
| 150 | // re-add all added hydrogen atoms
|
---|
| 151 | AddAtomsFromAtomicInfo(state->addedHydrogens);
|
---|
| 152 |
|
---|
| 153 | return ActionState::ptr(_state);
|
---|
| 154 | }
|
---|
| 155 |
|
---|
| 156 | bool AtomSaturateAction::canUndo() {
|
---|
| 157 | return true;
|
---|
| 158 | }
|
---|
| 159 |
|
---|
| 160 | bool AtomSaturateAction::shouldUndo() {
|
---|
| 161 | return true;
|
---|
| 162 | }
|
---|
| 163 | /** =========== end of function ====================== */
|
---|