source: src/Actions/FragmentationAction/FragmentationAutomationAction.cpp@ 9eb71b3

Action_Thermostats Add_AtomRandomPerturbation Add_RotateAroundBondAction Add_SelectAtomByNameAction Adding_Graph_to_ChangeBondActions Adding_MD_integration_tests Adding_StructOpt_integration_tests AutomationFragmentation_failures Candidate_v1.6.1 ChangeBugEmailaddress ChangingTestPorts ChemicalSpaceEvaluator Disabling_MemDebug Docu_Python_wait EmpiricalPotential_contain_HomologyGraph_documentation Enhance_userguide Enhanced_StructuralOptimization Enhanced_StructuralOptimization_continued Example_ManyWaysToTranslateAtom Exclude_Hydrogens_annealWithBondGraph Fix_ChronosMutex Fix_StatusMsg Fix_StepWorldTime_single_argument Fix_Verbose_Codepatterns ForceAnnealing_goodresults ForceAnnealing_oldresults ForceAnnealing_tocheck ForceAnnealing_with_BondGraph ForceAnnealing_with_BondGraph_continued ForceAnnealing_with_BondGraph_continued_betteresults ForceAnnealing_with_BondGraph_contraction-expansion GeometryObjects Gui_displays_atomic_force_velocity IndependentFragmentGrids_IntegrationTest JobMarket_RobustOnKillsSegFaults JobMarket_StableWorkerPool PythonUI_with_named_parameters QtGui_reactivate_TimeChanged_changes Recreated_GuiChecks RotateToPrincipalAxisSystem_UndoRedo StoppableMakroAction TremoloParser_IncreasedPrecision TremoloParser_MultipleTimesteps Ubuntu_1604_changes
Last change on this file since 9eb71b3 was 9eb71b3, checked in by Frederik Heber <frederik.heber@…>, 8 years ago

Commented out MemDebug include and Memory::ignore.

  • MemDebug clashes with various allocation operators that use a specific placement in memory. It is so far not possible to wrap new/delete fully. Hence, we stop this effort which so far has forced us to put ever more includes (with clashes) into MemDebug and thereby bloat compilation time.
  • MemDebug does not add that much usefulness which is not also provided by valgrind.
  • Property mode set to 100644
File size: 20.9 KB
Line 
1/*
2 * Project: MoleCuilder
3 * Description: creates and alters molecular systems
4 * Copyright (C) 2010-2012 University of Bonn. All rights reserved.
5 * Copyright (C) 2013 Frederik Heber. All rights reserved.
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/>.
22 */
23
24/*
25 * FragmentationAutomationAction.cpp
26 *
27 * Created on: May 18, 2012
28 * Author: heber
29 */
30
31// include config.h
32#ifdef HAVE_CONFIG_H
33#include <config.h>
34#endif
35
36#include <boost/archive/text_iarchive.hpp>
37// boost asio needs specific operator new
38#include <boost/asio.hpp>
39
40//#include "CodePatterns/MemDebug.hpp"
41
42//// include headers that implement a archive in simple text format
43#include <boost/archive/text_oarchive.hpp>
44#include <boost/archive/text_iarchive.hpp>
45
46//
47//#include <boost/mpl/remove.hpp>
48//#include <boost/lambda/lambda.hpp>
49
50//#include <iostream>
51
52#include "CodePatterns/Assert.hpp"
53#include "CodePatterns/Info.hpp"
54#include "CodePatterns/Log.hpp"
55
56#ifdef HAVE_JOBMARKET
57#include "JobMarket/Jobs/FragmentJob.hpp"
58#else
59#include "Jobs/JobMarket/FragmentJob.hpp"
60#endif
61
62#include "Fragmentation/Automation/FragmentJobQueue.hpp"
63#ifdef HAVE_JOBMARKET
64#include "Fragmentation/Automation/MPQCFragmentController.hpp"
65#else
66#include "Fragmentation/Automation/MPQCCommandFragmentController.hpp"
67#endif
68#include "Fragmentation/Exporters/ExportGraph_ToJobs.hpp"
69#include "Fragmentation/Summation/Containers/FragmentationChargeDensity.hpp"
70#include "Fragmentation/Summation/Containers/FragmentationLongRangeResults.hpp"
71#include "Fragmentation/Summation/Containers/FragmentationResultContainer.hpp"
72#include "Fragmentation/Summation/Containers/FragmentationShortRangeResults.hpp"
73#include "Fragmentation/Summation/Containers/MPQCData.hpp"
74#include "Fragmentation/KeySetsContainer.hpp"
75#if defined(HAVE_JOBMARKET) && defined(HAVE_VMG)
76#include "Fragmentation/Automation/VMGDebugGridFragmentController.hpp"
77#include "Fragmentation/Automation/VMGFragmentController.hpp"
78#include "Fragmentation/Summation/Containers/GridDownsampler.hpp"
79#include "Fragmentation/Summation/Containers/VMGData.hpp"
80#include "Fragmentation/Summation/Containers/VMGDataFused.hpp"
81#include "Fragmentation/Summation/Containers/VMGDataMap.hpp"
82#include "Fragmentation/Summation/Containers/VMGData_printKeyNames.hpp"
83#endif
84#include "World.hpp"
85
86#include <boost/bind.hpp>
87#include <boost/thread.hpp>
88#include <fstream>
89#include <iostream>
90#include <string>
91#include <vector>
92
93#include <boost/mpl/for_each.hpp>
94
95#include "Actions/FragmentationAction/FragmentationAutomationAction.hpp"
96
97using namespace MoleCuilder;
98
99// and construct the stuff
100#include "FragmentationAutomationAction.def"
101#include "Action_impl_pre.hpp"
102/** =========== define the function ====================== */
103
104class controller_AddOn;
105
106// needs to be defined for using the FragmentController
107controller_AddOn *getAddOn()
108{
109 return NULL;
110}
111
112static void updateSteps(Process &p, const size_t step, const size_t total)
113{
114 LOG(1, "There are " << step << " steps out of " << total << " done.");
115 p.setCurrStep(step);
116}
117
118template <class ResultClass>
119std::pair<double, double> getResiduals(const ResultClass &_result)
120{ return std::pair<double, double>(0.,0.); }
121
122std::pair<double, double> getResiduals(const MPQCData &_result)
123{ return std::make_pair(_result.accuracy, _result.desired_accuracy); }
124
125std::pair<double, double> getResiduals(const VMGData &_result)
126{
127 // sensibility check on absolute residual
128 if (_result.residual > 1e-5)
129 ELOG(2, "Encountered absolute residual greater than 1e-5: " << _result.residual);
130 // take smaller value of the two as just one of them needs to be less than precision
131 const double residual = std::min(_result.relative_residual, _result.residual);
132 return std::make_pair(residual, _result.precision);
133}
134
135template <class ResultClass>
136bool checkResults(const typename std::map<JobId_t, ResultClass> &_results)
137{
138 bool result = true;
139 for (typename std::map<JobId_t, ResultClass>::const_iterator iter = _results.begin();
140 iter != _results.end(); ++iter) {
141 std::pair<double, double> residuals = getResiduals(iter->second);
142 if (residuals.second != 0.) {
143 if (residuals.first >= residuals.second) {
144 ELOG(1, "Fragment Job " << iter->first << " converged to " << residuals.first
145 << " instead of " << residuals.second);
146 result = false;
147 }
148 } else {
149 LOG(4, "DEBUG: Not checking accuracy because desired precision not given.");
150 }
151 }
152 return result;
153}
154
155
156#ifdef HAVE_JOBMARKET
157/** This performs a direct sum calculation for the nuclei-nuclei interaction energy
158 * and forces for each fragment contained in \a shortrangedata.
159 *
160 * Results are (re)placed in \a _longrangedata.
161 *
162 * \warning This is only valid for fully open boundary conditions.
163 *
164 * \param _shortrangedata containing information on position and charges per fragment
165 * \param _longrangedata containing energy and forces on return
166 */
167/* Is not used currently, commented out to disable warning message.
168static void calculateNucleiNucleiLongRangeContribution(
169 const std::map<JobId_t, MPQCData> &_shortrangedata,
170 std::map<JobId_t, VMGData>& _longrangedata
171 )
172{
173 ASSERT( _shortrangedata.size() == _longrangedata.size(),
174 "calculateNucleiNucleiLongRangeContribution() - shortrange and longrange data have inequal size.");
175 std::map<JobId_t, VMGData>::iterator longrangeiter = _longrangedata.begin();
176 std::map<JobId_t, MPQCData>::const_iterator iter = _shortrangedata.begin();
177 for (;iter != _shortrangedata.end(); ++iter, ++longrangeiter) {
178 const MPQCData &data = iter->second;
179 VMGData &longrange_data = longrangeiter->second;
180 // set long-range contributions to zero
181 longrange_data.nuclei_long = 0.;
182 longrange_data.forces.clear();
183 longrange_data.forces.resize(data.positions.size(), FragmentForces::force_t(3,0.));
184 longrange_data.hasForces = true;
185 // go through positions and evaluate sum naively
186 ASSERT( data.positions.size() == data.charges.size(),
187 "calculateNucleiNucleiLongRangeContribution() - positions and charges differ in size.");
188 std::vector< std::vector<double> >::const_iterator positer = data.positions.begin();
189 std::vector< double >::const_iterator chargeiter = data.charges.begin();
190 FragmentForces::iterator forceiter = longrange_data.forces.begin();
191 for (; (positer != data.positions.end()) && (chargeiter != data.charges.end());
192 ++positer, ++chargeiter, ++forceiter) {
193 ASSERT( positer->size() == NDIM,
194 "calculateNucleiNucleiLongRangeContribution() - position "
195 +toString(std::distance(data.positions.begin(), positer))+" has not 3 components.");
196 const Vector position((*positer)[0], (*positer)[1], (*positer)[2]);
197
198 std::vector< std::vector<double> >::const_iterator otherpositer = data.positions.begin();
199 std::vector< double >::const_iterator otherchargeiter = data.charges.begin();
200 for (; (otherpositer != data.positions.end()) && (otherchargeiter != data.charges.end());
201 ++otherpositer, ++otherchargeiter) {
202 if ((positer == otherpositer) || (chargeiter == otherchargeiter))
203 continue;
204 ASSERT( otherpositer->size() == NDIM,
205 "calculateNucleiNucleiLongRangeContribution() - other position "
206 +toString(std::distance(data.positions.begin(), otherpositer))+" has not 3 components.");
207 const Vector otherposition((*otherpositer)[0], (*otherpositer)[1], (*otherpositer)[2]);
208 const Vector distance = position - otherposition;
209 const double invsqrdist = 1./distance.Norm();
210 const double factor = (*otherchargeiter)*invsqrdist*invsqrdist*invsqrdist;
211 (*forceiter)[0] = factor*distance[0];
212 (*forceiter)[1] = factor*distance[1];
213 (*forceiter)[2] = factor*distance[2];
214 longrange_data.nuclei_long += 0.5*(*chargeiter)*(*otherchargeiter)*invsqrdist;
215 }
216 }
217 }
218}
219*/
220#endif
221
222ActionState::ptr FragmentationFragmentationAutomationAction::performCall() {
223 boost::asio::io_service io_service;
224
225 // TODO: Have io_service run in second thread and merge with current again eventually
226
227 FragmentationResultContainer &container =
228 FragmentationResultContainer::getInstance();
229 const KeySetsContainer& keysets = FragmentJobQueue::getInstance().getKeySets();
230 const KeySetsContainer& forcekeysets = FragmentJobQueue::getInstance().getFullKeySets();
231 const FragmentJobQueue::edges_per_fragment_t &edges_per_fragment =
232 FragmentJobQueue::getInstance().getEdgesPerFragment();
233
234 size_t Exitflag = 0;
235 std::map<JobId_t, MPQCData> shortrangedata;
236#ifdef HAVE_JOBMARKET
237 {
238 const size_t NumberJobs = FragmentJobQueue::getInstance().size();
239 MPQCFragmentController mpqccontroller(io_service);
240 mpqccontroller.setHost(params.host.get());
241 mpqccontroller.setPort(params.port.get());
242 // Phase One: obtain ids
243 mpqccontroller.requestIds(NumberJobs);
244 if (mpqccontroller.getExitflag() != 0)
245 return Action::failure;
246
247 // Phase Two: add MPQCJobs and send
248 const bool AddJobsStatus = mpqccontroller.addJobsFromQueue(
249 params.DoLongrange.get() ? MPQCData::DoSampleDensity : MPQCData::DontSampleDensity,
250 params.DoValenceOnly.get() ? MPQCData::DoSampleValenceOnly : MPQCData::DontSampleValenceOnly
251 );
252 if (AddJobsStatus)
253 LOG(1, "INFO: Added jobs from FragmentJobsQueue.");
254 else {
255 ELOG(1, "Adding jobs failed.");
256 return Action::failure;
257 }
258 mpqccontroller.run();
259
260 // Phase Three: calculate result
261 setMaxSteps(NumberJobs);
262 mpqccontroller.setUpdateHandler(
263 boost::bind(&updateSteps, boost::ref(*this), _1, _2)
264 );
265 start();
266 boost::thread wait_thread(
267 boost::bind(&MPQCFragmentController::waitforResults, boost::ref(mpqccontroller), boost::cref(NumberJobs))
268 );
269 wait_thread.join();
270 stop();
271 if (mpqccontroller.getExitflag() != 0)
272 return Action::failure;
273
274 mpqccontroller.getResults(shortrangedata);
275 if (!checkResults(shortrangedata)) {
276 ELOG(1, "At least one of the fragments' energy could not be properly minimized.");
277 return Action::failure;
278 }
279 if (mpqccontroller.getExitflag() != 0) {
280 ELOG(1, "MPQCCommandFragmentController returned non-zero exit flag.");
281 return Action::failure;
282 }
283
284 Exitflag += mpqccontroller.getExitflag();
285 }
286#else
287 {
288 const size_t NumberJobs = FragmentJobQueue::getInstance().size();
289 MPQCCommandFragmentController mpqccontroller;
290 // Phase One: obtain ids: not needed, we have infinite pool
291
292 // Phase Two: add MPQCJobs and send
293 const size_t NoJobs = mpqccontroller.addJobsFromQueue(
294 params.DoLongrange.get() ? MPQCData::DoSampleDensity : MPQCData::DontSampleDensity,
295 params.DoValenceOnly.get() ? MPQCData::DoSampleValenceOnly : MPQCData::DontSampleValenceOnly,
296 params.executable.get().string()
297 );
298 if (NoJobs != NumberJobs) {
299 ELOG(1, "Not all jobs were added succesfully.");
300 return Action::failure;
301 }
302 LOG(1, "INFO: Added " << NoJobs << " from FragmentJobsQueue.");
303
304 // prepare process
305 setMaxSteps(NumberJobs);
306 mpqccontroller.setUpdateHandler(
307 boost::bind(&updateSteps, boost::ref(*this), _1, _2)
308 );
309 start();
310 mpqccontroller.run();
311 stop();
312 if (mpqccontroller.getExitflag() != 0) {
313 ELOG(1, "MPQCCommandFragmentController returned non-zero exit flag before getting results.");
314 return Action::failure;
315 }
316
317 // get back the results and place them in shortrangedata
318 mpqccontroller.getResults(shortrangedata);
319 ASSERT( shortrangedata.size() == NumberJobs,
320 "FragmentationFragmentationAutomationAction::performCall() - number of converted results "
321 +toString(shortrangedata.size())+" and number of jobs "+toString(NumberJobs)+ " differ.");
322 if (!checkResults(shortrangedata)) {
323 ELOG(1, "At least one of the fragments' energy could not be properly minimized.");
324 return Action::failure;
325 }
326 if (mpqccontroller.getExitflag() != 0) {
327 ELOG(1, "MPQCCommandFragmentController returned non-zero exit flag after getting results.");
328 return Action::failure;
329 }
330
331 Exitflag += mpqccontroller.getExitflag();
332 }
333#endif
334
335#if defined(HAVE_JOBMARKET) && defined(HAVE_VMG)
336 if (params.DoLongrange.get()) {
337 if ( const_cast<const World &>(World::getInstance()).getAllAtoms().size() == 0) {
338 STATUS("Please load the full molecule into the world before starting this action.");
339 return Action::failure;
340 }
341
342 // obtain combined charge density
343 std::map<JobId_t, MPQCData> shortrangedata_downsampled;
344 SamplingGridProperties domain(ExportGraph_ToJobs::getDomainGrid(params.level.get()));
345 FragmentationChargeDensity summedChargeDensity(
346 shortrangedata);
347 {
348 SamplingGrid zero_globalgrid(domain);
349 summedChargeDensity(
350 shortrangedata,
351 FragmentJobQueue::getInstance().getKeySets(),
352 zero_globalgrid);
353 }
354 const std::vector<SamplingGrid> full_sample = summedChargeDensity.getFullSampledGrid();
355 LOG(1, "INFO: There are " << shortrangedata.size() << " short-range and "
356 << full_sample.size() << " level-wise long-range jobs.");
357
358 // check boundary conditions
359 const BoundaryConditions::Conditions_t &conditions =
360 World::getInstance().getDomain().getConditions();
361 const bool OpenBoundaryConditions =
362 !((conditions[0] == BoundaryConditions::Wrap) &&
363 (conditions[1] == BoundaryConditions::Wrap) &&
364 (conditions[2] == BoundaryConditions::Wrap));
365 LOG(1, std::string("INFO: Using ")
366 << (OpenBoundaryConditions ? "open" : "periodic")
367 << " boundary conditions.");
368
369 // Phase Four: obtain more ids
370 std::map<JobId_t, VMGData> longrangedata;
371 {
372 VMGFragmentController vmgcontroller(io_service);
373 vmgcontroller.setHost(params.host.get());
374 vmgcontroller.setPort(params.port.get());
375 const size_t NoJobs = shortrangedata.size()+full_sample.size();
376 vmgcontroller.requestIds(2*NoJobs);
377 if (vmgcontroller.getExitflag() != 0) {
378 ELOG(1, "VMGFragmentController returned non-zero exit flag on requesting long-range ids.");
379 return Action::failure;
380 }
381
382 // Phase Five a: create VMGJobs for electronic charge distribution
383 const size_t near_field_cells = params.near_field_cells.get();
384 const size_t interpolation_degree = params.interpolation_degree.get();
385 if (!vmgcontroller.createLongRangeJobs(
386 shortrangedata,
387 full_sample,
388 near_field_cells,
389 interpolation_degree,
390 VMGFragmentController::DontSampleParticles,
391 VMGFragmentController::DoTreatGrid,
392 params.DoValenceOnly.get() ? MPQCData::DoSampleValenceOnly : MPQCData::DontSampleValenceOnly,
393 params.DoPrintDebug.get(),
394 OpenBoundaryConditions,
395 params.DoSmearCharges.get(),
396 false)) {
397 STATUS("Could not create long-range jobs for electronic charge distribution.");
398 return Action::failure;
399 }
400
401 // Phase Six a: calculate result
402 vmgcontroller.waitforResults(NoJobs);
403 if (vmgcontroller.getExitflag() != 0) {
404 ELOG(1, "VMGFragmentController returned non-zero exit flag before getting results.");
405 return Action::failure;
406 }
407 vmgcontroller.getResults(longrangedata);
408 ASSERT( NoJobs == longrangedata.size(),
409 "FragmentationFragmentationAutomationAction::performCall() - number of MPQCresults+"
410 +toString(full_sample.size())+"="+toString(NoJobs)
411 +" and first VMGresults "+toString(longrangedata.size())+" don't match.");
412 if (!checkResults(longrangedata)) {
413 ELOG(1, "At least one of the fragments' electronic long-range potential could not be properly minimized.");
414 return Action::failure;
415 }
416 Exitflag += vmgcontroller.getExitflag();
417
418 {
419 std::map<JobId_t, VMGData> longrangedata_both;
420 // Phase Five b: create VMGJobs for nuclei charge distributions
421 const size_t near_field_cells = params.near_field_cells.get();
422 const size_t interpolation_degree = params.interpolation_degree.get();
423 if (!vmgcontroller.createLongRangeJobs(
424 shortrangedata,
425 full_sample,
426 near_field_cells,
427 interpolation_degree,
428 VMGFragmentController::DoSampleParticles,
429 VMGFragmentController::DoTreatGrid,
430 params.DoValenceOnly.get() ? MPQCData::DoSampleValenceOnly : MPQCData::DontSampleValenceOnly,
431 params.DoPrintDebug.get(),
432 OpenBoundaryConditions,
433 params.DoSmearCharges.get(),
434 params.UseImplicitCharges.get())) {
435 STATUS("Could not create long-range jobs for nuclei charge distribution.");
436 return Action::failure;
437 }
438
439 // Phase Six b: calculate result
440 vmgcontroller.waitforResults(NoJobs);
441 if (vmgcontroller.getExitflag() != 0)
442 return Action::failure;
443 vmgcontroller.getResults(longrangedata_both);
444 ASSERT( NoJobs == longrangedata_both.size(),
445 "FragmentationFragmentationAutomationAction::performCall() - number of MPQCresults+"
446 +toString(full_sample.size())+"="+toString(NoJobs)
447 +" and second VMGresults "+toString(longrangedata_both.size())+" don't match.");
448 if (!checkResults(longrangedata_both)) {
449 ELOG(1, "At least one of the fragments' nuclei long-range potential could not be properly minimized.");
450 return Action::failure;
451 }
452 if (vmgcontroller.getExitflag() != 0) {
453 ELOG(1, "VMGFragmentController returned non-zero exit flag after getting results.");
454 return Action::failure;
455 }
456 Exitflag += vmgcontroller.getExitflag();
457
458 // now replace nuclei-nuclei contribution with values from direct summation (is exact for
459 // open boundary conditions
460 //
461 // NOTE: We need to calculate both_sampled_potential for fitting partial charges,
462 // nowhere else is this quantity needed.
463 //if (OpenBoundaryConditions)
464 // calculateNucleiNucleiLongRangeContribution(shortrangedata, longrangedata_both);
465
466 // go through either data and replace nuclei_long with contribution from both
467 ASSERT( longrangedata.size() == longrangedata_both.size(),
468 "FragmentationFragmentationAutomationAction::performCall() - longrange results have different sizes.");
469 std::map<JobId_t, VMGData>::iterator destiter = longrangedata.begin();
470 std::map<JobId_t, VMGData>::const_iterator srciter = longrangedata_both.begin();
471 for (;destiter != longrangedata.end(); ++srciter, ++destiter) {
472 destiter->second.both_sampled_potential = srciter->second.sampled_potential;
473 destiter->second.nuclei_long = srciter->second.nuclei_long;
474 destiter->second.forces = srciter->second.forces;
475 destiter->second.hasForces = srciter->second.hasForces;
476 }
477 }
478 }
479
480 if (params.DoPrintDebug.get()) {
481 std::map<JobId_t, std::string> debugData;
482 {
483 if (!full_sample.empty()) {
484 // create debug jobs for each level to print the summed-up potential to vtk files
485 VMGDebugGridFragmentController debugcontroller(io_service);
486 debugcontroller.setHost(params.host.get());
487 debugcontroller.setPort(params.port.get());
488 debugcontroller.requestIds(full_sample.size());
489 if (!debugcontroller.createDebugJobs(full_sample, OpenBoundaryConditions)) {
490 STATUS("Could not create debug jobs.");
491 return Action::failure;
492 }
493 debugcontroller.waitforResults(full_sample.size());
494 debugcontroller.getResults(debugData);
495 Exitflag += debugcontroller.getExitflag();
496 }
497 }
498 }
499 container.clear();
500 container.addFullResults(keysets, forcekeysets, edges_per_fragment, shortrangedata, longrangedata);
501 } else {
502 container.clear();
503 container.addShortRangeResults(keysets, forcekeysets, edges_per_fragment, shortrangedata);
504 }
505#else
506 container.clear();
507 container.addShortRangeResults(keysets, forcekeysets, edges_per_fragment, shortrangedata);
508#endif
509
510 // now clear all present jobs as we are done
511 FragmentJobQueue::getInstance().clear();
512
513 if (Exitflag != 0)
514 STATUS("Controller has returned failure.");
515 return (Exitflag == 0) ? Action::success : Action::failure;
516}
517
518ActionState::ptr FragmentationFragmentationAutomationAction::performUndo(ActionState::ptr _state) {
519 return Action::success;
520}
521
522ActionState::ptr FragmentationFragmentationAutomationAction::performRedo(ActionState::ptr _state){
523 return Action::success;
524}
525
526bool FragmentationFragmentationAutomationAction::canUndo() {
527 return false;
528}
529
530bool FragmentationFragmentationAutomationAction::shouldUndo() {
531 return false;
532}
533/** =========== end of function ====================== */
Note: See TracBrowser for help on using the repository browser.