Ignore:
Timestamp:
Aug 28, 2010, 12:57:56 AM (15 years ago)
Author:
Frederik Heber <heber@…>
Branches:
Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, Candidate_v1.7.0, Candidate_v1.7.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable
Children:
966e12
Parents:
53d01c
git-author:
Frederik Heber <heber@…> (08/26/10 21:05:34)
git-committer:
Frederik Heber <heber@…> (08/28/10 00:57:56)
Message:

All Actions are converted to the new macro framework.

  • included all three values that have been used to create or convert the files
    • createdef.sh
    • createCpp.sh
    • createHeader.sh
Location:
src/Actions/AtomAction
Files:
5 added
9 edited

Legend:

Unmodified
Added
Removed

  • src/Actions/AtomAction/AddAction.cpp

    r53d01c r1fd675  
    3939#include "AddAction.def"
    4040#include "Action_impl_pre.hpp"
    41 
    4241/** =========== define the function ====================== */
    4342Action::state_ptr AtomAddAction::performCall() {

  • src/Actions/AtomAction/ChangeElementAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/AtomAction/ChangeElementAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "Descriptors/AtomIdDescriptor.hpp"
    2523#include "atom.hpp"
    … …  
    3735using namespace std;
    3836
    39 #include "UIElements/UIFactory.hpp"
    40 #include "UIElements/Dialog.hpp"
    41 #include "Actions/ValueStorage.hpp"
     37#include "Actions/AtomAction/ChangeElementAction.hpp"
    4238
    43 typedef std::map<int, const element *> ElementMap;
    44 
    45 // memento to remember the state when undoing
    46 
    47 class AtomChangeElementState : public ActionState {
    48 public:
    49   AtomChangeElementState(ElementMap _Elements, const element *_elemental) :
    50     Elements(_Elements),
    51     elemental(_elemental)
    52   {}
    53   ElementMap Elements;
    54   const element *elemental;
    55 };
    56 
    57 const char AtomChangeElementAction::NAME[] = "change-element";
    58 
    59 AtomChangeElementAction::AtomChangeElementAction() :
    60   Action(NAME)
    61 {}
    62 
    63 AtomChangeElementAction::~AtomChangeElementAction()
    64 {}
    65 
    66 void AtomChangeElement(element *elemental) {
    67   ValueStorage::getInstance().setCurrentValue(AtomChangeElementAction::NAME, elemental);
    68   ActionRegistry::getInstance().getActionByName(AtomChangeElementAction::NAME)->call(Action::NonInteractive);
    69 };
    70 
    71 void AtomChangeElementAction::getParametersfromValueStorage()
    72 {};
    73 
    74 Dialog* AtomChangeElementAction::fillDialog(Dialog *dialog) {
    75   ASSERT(dialog,"No Dialog given when filling action dialog");
    76 
    77   dialog->queryElement(NAME, ValueStorage::getInstance().getDescription(NAME));
    78 
    79 return dialog;
    80 }
    81 
     39// and construct the stuff
     40#include "ChangeElementAction.def"
     41#include "Action_impl_pre.hpp"
     42/** =========== define the function ====================== */
    8243Action::state_ptr AtomChangeElementAction::performCall() {
    8344  atom *first = NULL;
    84   const element *elemental;
    8545  molecule *mol = NULL;
    8646
    87   ValueStorage::getInstance().queryCurrentValue(NAME, elemental);
     47  // obtain information
     48  getParametersfromValueStorage();
    8849
    8950  // create undo state
    … …  
    9253    Elements.insert(std::pair<int, const element *> (iter->second->getId(), iter->second->getType()));
    9354  }
    94   AtomChangeElementState *UndoState = new AtomChangeElementState(Elements, elemental);
     55  AtomChangeElementState *UndoState = new AtomChangeElementState(Elements, params);
    9556
    9657  for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
    9758    first = iter->second;
    98     DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << *elemental << "." << endl);
     59    DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << *params.elemental << "." << endl);
    9960    mol = first->getMolecule();
    10061    first->removeFromMolecule(); // remove atom
    101     first->setType(elemental);
     62    first->setType(params.elemental);
    10263    mol->AddAtom(first);  // add atom to ensure correctness of formula
    10364  }
    … …  
    13091    mol = first->getMolecule();
    13192    first->removeFromMolecule(); // remove atom
    132     first->setType(state->elemental);
     93    first->setType(state->params.elemental);
    13394    mol->AddAtom(first);  // add atom to ensure correctness of formula
    13495  }
    … …  
    148109  return NAME;
    149110}
     111/** =========== end of function ====================== */

  • src/Actions/AtomAction/ChangeElementAction.hpp

    r53d01c r1fd675  
    99#define CHANGELEMENTACTION_HPP_
    1010
     11
    1112#include "Actions/Action.hpp"
    1213
    13 class element;
    14 
    15 void AtomChangeElement(element *elemental);
    16 
    17 class AtomChangeElementAction : public Action {
    18   friend void AtomChangeElement(element *elemental);
    19 
    20 public:
    21   AtomChangeElementAction();
    22   virtual ~AtomChangeElementAction();
    23 
    24   bool canUndo();
    25   bool shouldUndo();
    26 
    27   virtual const std::string getName();
    28 protected:
    29   virtual Dialog * fillDialog(Dialog*);
    30 private:
    31   virtual void getParametersfromValueStorage();
    32   virtual Action::state_ptr performCall();
    33   virtual Action::state_ptr performUndo(Action::state_ptr);
    34   virtual Action::state_ptr performRedo(Action::state_ptr);
    35 
    36   static const char NAME[];
    37 };
     14#include "ChangeElementAction.def"
     15#include "Action_impl_header.hpp"
    3816
    3917#endif /* CHANGELEMENTACTION_HPP_ */

  • src/Actions/AtomAction/RemoveAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/AtomAction/RemoveAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "atom.hpp"
    2523#include "AtomicInfo.hpp"
    … …  
    3533using namespace std;
    3634
    37 #include "UIElements/UIFactory.hpp"
    38 #include "UIElements/Dialog.hpp"
    39 #include "Actions/ValueStorage.hpp"
     35#include "Actions/AtomAction/RemoveAction.hpp"
    4036
    41 // memento to remember the state when undoing
    42 
    43 class AtomRemoveState : public ActionState {
    44 public:
    45   AtomRemoveState(std::vector<AtomicInfo> _Walkers) :
    46     Walkers(_Walkers)
    47   {}
    48   std::vector<AtomicInfo> Walkers;
    49 };
    50 
    51 const char AtomRemoveAction::NAME[] = "remove-atom";
    52 
    53 AtomRemoveAction::AtomRemoveAction() :
    54   Action(NAME)
    55 {}
    56 
    57 AtomRemoveAction::~AtomRemoveAction()
    58 {}
    59 
    60 void AtomRemove() {
    61   ActionRegistry::getInstance().getActionByName(AtomRemoveAction::NAME)->call(Action::NonInteractive);
    62 };
    63 
    64 void AtomRemoveAction::getParametersfromValueStorage()
    65 {};
    66 
    67 Dialog* AtomRemoveAction::fillDialog(Dialog *dialog) {
    68   ASSERT(dialog,"No Dialog given when filling action dialog");
    69 
    70   dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
    71 
    72   return dialog;
    73 }
    74 
     37// and construct the stuff
     38#include "RemoveAction.def"
     39#include "Action_impl_pre.hpp"
     40/** =========== define the function ====================== */
    7541Action::state_ptr AtomRemoveAction::performCall() {
    7642  atom *first = NULL;
    … …  
    8147    Walkers.push_back(AtomicInfo(*(iter->second)));
    8248  }
    83   AtomRemoveState *UndoState = new AtomRemoveState(Walkers);
     49  AtomRemoveState *UndoState = new AtomRemoveState(Walkers, params);
    8450
    8551  // remove all selected atoms
    … …  
    145111  return NAME;
    146112}
     113/** =========== end of function ====================== */

  • src/Actions/AtomAction/RemoveAction.hpp

    r53d01c r1fd675  
    1111#include "Actions/Action.hpp"
    1212
    13 void AtomRemove();
    14 
    15 class AtomRemoveAction : public Action {
    16   friend void AtomRemove();
    17 
    18 public:
    19   AtomRemoveAction();
    20   virtual ~AtomRemoveAction();
    21 
    22   bool canUndo();
    23   bool shouldUndo();
    24 
    25   virtual const std::string getName();
    26 protected:
    27   virtual Dialog * fillDialog(Dialog*);
    28 private:
    29   virtual void getParametersfromValueStorage();
    30   virtual Action::state_ptr performCall();
    31   virtual Action::state_ptr performUndo(Action::state_ptr);
    32   virtual Action::state_ptr performRedo(Action::state_ptr);
    33 
    34   static const char NAME[];
    35 };
     13#include "RemoveAction.def"
     14#include "Action_impl_header.hpp"
    3615
    3716#endif /* REMOVEACTION_HPP_ */

  • src/Actions/AtomAction/RotateAroundOriginByAngleAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/AtomAction/RotateAroundOriginByAngleAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "Helpers/Log.hpp"
    2523#include "Helpers/Verbose.hpp"
    … …  
    3634using namespace std;
    3735
    38 #include "UIElements/UIFactory.hpp"
    39 #include "UIElements/Dialog.hpp"
    40 #include "Actions/ValueStorage.hpp"
     36#include "Actions/AtomAction/RotateAroundOriginByAngleAction.hpp"
    4137
    42 /****** AtomRotateAroundOriginByAngleAction *****/
    43 
    44 // memento to remember the state when undoing
    45 
    46 class AtomRotateAroundOriginByAngleState : public ActionState {
    47 public:
    48   AtomRotateAroundOriginByAngleState(std::vector<atom*> _selectedAtoms, const Vector &_Axis, const double _alpha) :
    49     selectedAtoms(_selectedAtoms),
    50     Axis(_Axis),
    51     alpha(_alpha)
    52   {}
    53   std::vector<atom*> selectedAtoms;
    54   Vector Axis;
    55   double alpha;
    56 };
    57 
    58 const char AtomRotateAroundOriginByAngleAction::NAME[] = "rotate-origin";
    59 
    60 AtomRotateAroundOriginByAngleAction::AtomRotateAroundOriginByAngleAction() :
    61   Action(NAME)
    62 {}
    63 
    64 AtomRotateAroundOriginByAngleAction::~AtomRotateAroundOriginByAngleAction()
    65 {}
    66 
    67 void AtomRotateAroundOriginByAngle(const Vector &Axis, double angle) {
    68   ValueStorage::getInstance().setCurrentValue(AtomRotateAroundOriginByAngleAction::NAME, angle);
    69   ValueStorage::getInstance().setCurrentValue("position", Axis);
    70   ActionRegistry::getInstance().getActionByName(AtomRotateAroundOriginByAngleAction::NAME)->call(Action::NonInteractive);
    71 };
    72 
    73 void AtomRotateAroundOriginByAngleAction::getParametersfromValueStorage()
    74 {};
    75 
    76 Dialog* AtomRotateAroundOriginByAngleAction::fillDialog(Dialog *dialog) {
    77   ASSERT(dialog,"No Dialog given when filling action dialog");
    78 
    79   dialog->queryDouble(NAME, ValueStorage::getInstance().getDescription(NAME));
    80   dialog->queryVector("position", false, ValueStorage::getInstance().getDescription("position"));
    81 
    82   return dialog;
    83 }
    84 
     38// and construct the stuff
     39#include "RotateAroundOriginByAngleAction.def"
     40#include "Action_impl_pre.hpp"
     41/** =========== define the function ====================== */
    8542Action::state_ptr AtomRotateAroundOriginByAngleAction::performCall() {
    86   double alpha = 0.;
    87   Vector Axis;
    8843  std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    8944
    90   // obtain axis to rotate to
    91   ValueStorage::getInstance().queryCurrentValue(NAME, alpha);
    92   ValueStorage::getInstance().queryCurrentValue("position", Axis);
     45  // obtain information
     46  getParametersfromValueStorage();
    9347
    9448  // check whether Axis is valid
    95   if (Axis.IsZero())
     49  if (params.Axis.IsZero())
    9650    return Action::failure;
    9751
    9852  // convert from degrees to radian
    99   alpha *= M_PI/180.;
     53  params.angle *= M_PI/180.;
    10054
    10155  // Creation Line that is the rotation axis
    102   Line RotationAxis(Vector(0.,0.,0.), Axis);
     56  Line RotationAxis(Vector(0.,0.,0.), params.Axis);
    10357
    104   DoLog(0) && (Log() << Verbose(0) << "Rotate around origin by " << alpha << " radian, axis from origin to " << Axis << "." << endl);
     58  DoLog(0) && (Log() << Verbose(0) << "Rotate around origin by " << params.angle << " radian, axis from origin to " << params.Axis << "." << endl);
    10559  // TODO: use AtomSet::rotate?
    10660  for (std::vector<atom *>::iterator iter = selectedAtoms.begin(); iter != selectedAtoms.end(); ++iter) {
    107     (*iter)->setPosition(RotationAxis.rotateVector((*iter)->getPosition(), alpha));
     61    (*iter)->setPosition(RotationAxis.rotateVector((*iter)->getPosition(), params.angle));
    10862  }
    10963  DoLog(0) && (Log() << Verbose(0) << "done." << endl);
    110   return Action::state_ptr(new AtomRotateAroundOriginByAngleState(World::getInstance().getSelectedAtoms(), Axis, alpha));
     64  return Action::state_ptr(new AtomRotateAroundOriginByAngleState(World::getInstance().getSelectedAtoms(), params));
    11165}
    11266
    … …  
    11569
    11670  // Creation Line that is the rotation axis
    117   Line RotationAxis(Vector(0.,0.,0.), state->Axis);
     71  Line RotationAxis(Vector(0.,0.,0.), state->params.Axis);
    11872
    11973  for (std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter) {
    120     (*iter)->setPosition(RotationAxis.rotateVector((*iter)->getPosition(), -state->alpha));
     74    (*iter)->setPosition(RotationAxis.rotateVector((*iter)->getPosition(), -state->params.angle));
    12175  }
    12276
    … …  
    12882
    12983  // Creation Line that is the rotation axis
    130   Line RotationAxis(Vector(0.,0.,0.), state->Axis);
     84  Line RotationAxis(Vector(0.,0.,0.), state->params.Axis);
    13185
    13286  for (std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter) {
    133     (*iter)->setPosition(RotationAxis.rotateVector((*iter)->getPosition(), state->alpha));
     87    (*iter)->setPosition(RotationAxis.rotateVector((*iter)->getPosition(), state->params.angle));
    13488  }
    13589
    … …  
    148102  return NAME;
    149103}
     104/** =========== end of function ====================== */

  • src/Actions/AtomAction/RotateAroundOriginByAngleAction.hpp

    r53d01c r1fd675  
    1111#include "Actions/Action.hpp"
    1212
    13 class Vector;
    14 
    15 void AtomRotateOrigin(Vector &Axis);
    16 
    17 class AtomRotateAroundOriginByAngleAction : public Action {
    18   friend void AtomRotateAroundOriginByAngle(const Vector &Axis, double angle);
    19 
    20 public:
    21   AtomRotateAroundOriginByAngleAction();
    22   virtual ~AtomRotateAroundOriginByAngleAction();
    23 
    24   bool canUndo();
    25   bool shouldUndo();
    26 
    27   virtual const std::string getName();
    28 protected:
    29   virtual Dialog * fillDialog(Dialog *dialog);
    30 private:
    31   virtual void getParametersfromValueStorage();
    32   virtual Action::state_ptr performCall();
    33   virtual Action::state_ptr performUndo(Action::state_ptr);
    34   virtual Action::state_ptr performRedo(Action::state_ptr);
    35 
    36   static const char NAME[];
    37 };
    38 
     13#include "RotateAroundOriginByAngleAction.def"
     14#include "Action_impl_header.hpp"
    3915
    4016#endif // ROTATEAROUNDORIGINBYANGLEACTION_HPP

  • src/Actions/AtomAction/TranslateAction.cpp

    r53d01c r1fd675  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Actions/AtomAction/TranslateAction.hpp"
    23 #include "Actions/ActionRegistry.hpp"
    2422#include "Helpers/Log.hpp"
    2523#include "atom.hpp"
    … …  
    3432using namespace std;
    3533
    36 #include "UIElements/UIFactory.hpp"
    37 #include "UIElements/Dialog.hpp"
    38 #include "Actions/ValueStorage.hpp"
     34#include "Actions/AtomAction/TranslateAction.hpp"
    3935
    40 /****** AtomTranslateAction *****/
    41 
    42 // memento to remember the state when undoing
    43 
    44 class AtomTranslateState : public ActionState {
    45 public:
    46   AtomTranslateState(const std::vector<atom*> &_selectedAtoms, const Vector &_v, const bool _periodic) :
    47     selectedAtoms(_selectedAtoms),
    48     v(_v),
    49     periodic(_periodic)
    50   {}
    51   std::vector<atom*> selectedAtoms;
    52   Vector v;
    53   bool periodic;
    54 };
    55 
    56 const char AtomTranslateAction::NAME[] = "translate-atoms";
    57 
    58 AtomTranslateAction::AtomTranslateAction() :
    59   Action(NAME)
    60 {}
    61 
    62 AtomTranslateAction::~AtomTranslateAction()
    63 {}
    64 
    65 void AtomTranslate(Vector &x, bool periodic = false) {
    66   ValueStorage::getInstance().setCurrentValue(AtomTranslateAction::NAME, x);
    67   ValueStorage::getInstance().setCurrentValue("periodic", periodic);
    68   ActionRegistry::getInstance().getActionByName(AtomTranslateAction::NAME)->call(Action::NonInteractive);
    69 };
    70 
    71 void AtomTranslateAction::getParametersfromValueStorage()
    72 {};
    73 
    74 Dialog* AtomTranslateAction::fillDialog(Dialog *dialog) {
    75   ASSERT(dialog,"No Dialog given when filling action dialog");
    76 
    77   dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
    78   dialog->queryBoolean("periodic", ValueStorage::getInstance().getDescription("periodic"));
    79 
    80   return dialog;
    81 }
    82 
     36// and construct the stuff
     37#include "TranslateAction.def"
     38#include "Action_impl_pre.hpp"
     39/** =========== define the function ====================== */
    8340Action::state_ptr AtomTranslateAction::performCall() {
    84   Vector v;
    85   bool periodic = false;
    8641  Box &domain = World::getInstance().getDomain();
    8742  std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    8843
    89   ValueStorage::getInstance().queryCurrentValue(NAME, v);
    90   if (!ValueStorage::getInstance().queryCurrentValue("periodic", periodic, true))
    91     periodic = false;
     44  // obtain information
     45  getParametersfromValueStorage();
    9246
    9347  // TODO: use AtomSet::translate
    9448  for (std::vector<atom *>::iterator iter = selectedAtoms.begin(); iter != selectedAtoms.end(); ++iter) {
    95     *(*iter) += v;
    96     if (periodic)
     49    *(*iter) += params.x;
     50    if (params.periodic)
    9751      (*iter)->setPosition(domain.WrapPeriodically((*iter)->getPosition()));
    9852  }
    9953
    100   return Action::state_ptr(new AtomTranslateState(selectedAtoms, v, periodic));
     54  return Action::state_ptr(new AtomTranslateState(selectedAtoms, params));
    10155}
    10256
    … …  
    10660
    10761  for (std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter) {
    108     *(*iter) -= state->v;
    109     if (state->periodic)
     62    *(*iter) -= state->params.x;
     63    if (state->params.periodic)
    11064      (*iter)->setPosition(domain.WrapPeriodically((*iter)->getPosition()));
    11165  }
    … …  
    11973
    12074  for (std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter) {
    121     *(*iter) += state->v;
    122     if (state->periodic)
     75    *(*iter) += state->params.x;
     76    if (state->params.periodic)
    12377      (*iter)->setPosition(domain.WrapPeriodically((*iter)->getPosition()));
    12478  }
    … …  
    13892  return NAME;
    13993}
     94/** =========== end of function ====================== */

  • src/Actions/AtomAction/TranslateAction.hpp

    r53d01c r1fd675  
    1010
    1111#include "Actions/Action.hpp"
    12 #include "LinearAlgebra/Vector.hpp"
    1312
    14 void AtomTranslate(Vector &x, bool periodic);
    15 
    16 class AtomTranslateAction : public Action {
    17   friend void AtomTranslate(Vector &x, bool periodic);
    18 
    19 public:
    20   AtomTranslateAction();
    21   virtual ~AtomTranslateAction();
    22 
    23   bool canUndo();
    24   bool shouldUndo();
    25 
    26   virtual const std::string getName();
    27 protected:
    28   virtual Dialog * fillDialog(Dialog *dialog);
    29 private:
    30   virtual void getParametersfromValueStorage();
    31   virtual Action::state_ptr performCall();
    32   virtual Action::state_ptr performUndo(Action::state_ptr);
    33   virtual Action::state_ptr performRedo(Action::state_ptr);
    34 
    35   static const char NAME[];
    36 };
    37 
     13#include "TranslateAction.def"
     14#include "Action_impl_header.hpp"
    3815
    3916#endif // TRANSLATEACTION_HPP
Note: See TracChangeset for help on using the changeset viewer.