Bug Summary

File:OMOptim/OMOptim/build/../Core/Problems/OptimResult.cpp
Warning:line 333, column 9
Value stored to 'iiSubBlock' during its initialization is never read

Annotated Source Code

[?] Use j/k keys for keyboard navigation

1// $Id$
2/**
3 * This file is part of OpenModelica.
4 *
5 * Copyright (c) 1998-CurrentYear, Open Source Modelica Consortium (OSMC),
6 * c/o Linköpings universitet, Department of Computer and Information Science,
7 * SE-58183 Linköping, Sweden.
8 *
9 * All rights reserved.
10 *
11 * THIS PROGRAM IS PROVIDED UNDER THE TERMS OF GPL VERSION 3 LICENSE OR
12 * THIS OSMC PUBLIC LICENSE (OSMC-PL).
13 * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
14 * OF THE OSMC PUBLIC LICENSE OR THE GPL VERSION 3, ACCORDING TO RECIPIENTS CHOICE.
15 *
16 * The OpenModelica software and the Open Source Modelica
17 * Consortium (OSMC) Public License (OSMC-PL) are obtained
18 * from OSMC, either from the above address,
19 * from the URLs: http://www.ida.liu.se/projects/OpenModelica or
20 * http://www.openmodelica.org, and in the OpenModelica distribution.
21 * GNU version 3 is obtained from: http://www.gnu.org/copyleft/gpl.html.
22 *
23 * This program is distributed WITHOUT ANY WARRANTY; without
24 * even the implied warranty of MERCHANTABILITY or FITNESS
25 * FOR A PARTICULAR PURPOSE, EXCEPT AS EXPRESSLY SET FORTH
26 * IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE CONDITIONS OF OSMC-PL.
27 *
28 * See the full OSMC Public License conditions for more details.
29 *
30 * Main contributor 2010, Hubert Thierot, CEP - ARMINES (France)
31 * Main contributor 2010, Hubert Thierot, CEP - ARMINES (France)
32
33 @file OptimResult.cpp
34 @brief Comments for file documentation.
35 @author Hubert Thieriot, hubert.thieriot@mines-paristech.fr
36 Company : CEP - ARMINES (France)
37 http://www-cep.ensmp.fr/english/
38 @version
39
40 */
41#include "OptimResult.h"
42#include "Optimization.h"
43#include "CSVBase.h"
44#include "Project.h"
45#include "VariablesManip.h"
46#include "LowTools.h"
47
48OptimResult::OptimResult(Project* project):Result(project)
49{
50 _recomputedVariables = new MOOptVector(true,true,true,this);
51 _optObjectivesResults = new MOOptVector(true,false,true,this); //objectives are constant for one scan
52 _optVariablesResults= new MOOptVector(true,false,true,this); //optimized parameters are constant for one scan
53
54 // files to copy
55 _filesToCopy.push_back(QFileInfo("iteration*.sav"));
56
57 _optVarsFrontFileName = "optVarsFront.csv";
58 _allVarsFrontFileName = "allVarsFront.csv";
59
60 _algo = NULL__null;
61 _curPoint = -1;
62 _curScan = -1;
63}
64
65
66
67OptimResult::OptimResult(Project* project, const Optimization & problem)
68 :Result((ProjectBase*)project,problem)
69
70{
71
72 _omProject = project;
73 _models = problem.models();
74
75
76 _recomputedVariables = new MOOptVector(true,true,true,this);
77 _optObjectivesResults = new MOOptVector(true,false,true,this); //objectives are constant for one scan
78 _optVariablesResults= new MOOptVector(true,false,true,this); //optimized parameters are constant for one scan
79
80
81 // files to copy
82 _filesToCopy.push_back(QFileInfo("iteration*.sav"));
83
84 _optVarsFrontFileName = "optVarsFront.csv";
85 _allVarsFrontFileName = "allVarsFront.csv";
86
87 _curPoint = -1;
88 _curScan = -1;
89
90 _algo = problem.getCurAlgo()->clone();
91// _algo->setParent(this);
92
93}
94
95OptimResult::OptimResult(Project* project,const QDomElement & domResult,const Optimization & problem,QDir resultDir,bool &ok)
96 :Result((ProjectBase*)project,(const Problem&)problem)
97{
98
99 ok = true;
100 _models = problem.models();
101 this->setSaveFolder(resultDir.absolutePath());
102
103 _recomputedVariables = new MOOptVector(true,true,true,this);
104 _optObjectivesResults = new MOOptVector(true,false,true,this); //objectives are constant for one scan
105 _optVariablesResults= new MOOptVector(true,false,true,this); //optimized parameters are constant for one scan
106 _algo = NULL__null;
107
108 if(domResult.isNull() || (domResult.tagName()!=OptimResult::className()))
109 {
110 ok = false;
111 return;
112 }
113
114 // files to copy
115 _filesToCopy.push_back(QFileInfo("iteration*.sav"));
116
117 _optVarsFrontFileName = "optVarsFront.csv";
118 _allVarsFrontFileName = "allVarsFront.csv";
119
120 _curPoint = -1;
121 _curScan = -1;
122
123 _algo = problem.getCurAlgo()->clone();
124// _algo->setParent(this);
125
126 setSuccess(true);
127
128 //**********
129 // Result
130 //**********
131 // OptVarResult from optVar, OptObjResult from OptObj...
132 this->optVariablesResults()->clear();
133 for(int i=0;i<problem.optimizedVariables()->size();i++)
134 {
135 this->optVariablesResults()->addItem(new VariableResult(*problem.optimizedVariables()->at(i)));
136 }
137
138 this->optObjectivesResults()->clear();
139 for(int i=0;i<problem.objectives()->size();i++)
140 {
141 this->optObjectivesResults()->addItem(new VariableResult(*problem.objectives()->at(i)));
142 }
143
144 //Infos
145 QDomElement domResInfos = domResult.firstChildElement("Infos");
146 this->setName(domResInfos.attribute("name", "" ));
147 QString date = domResInfos.attribute("date");
148 this->_date = QDateTime::fromString(date);
149 QString duration = domResInfos.attribute("duration");
150 this->_duration = QTime::fromString(duration);
151 int savVersion = domResInfos.attribute("version",0).toInt();
152
153
154// // Blocksubs
155// QDomElement domBlocks = domResult.firstChildElement("AllBlockSubstitutions");
156// QDomElement domBlock = domBlocks.firstChildElement();
157// QRegExp regExp("BlockSubstitutions[\\d]+");
158
159// while(!domBlock.isNull())
160// {
161// if(regExp.exactMatch(domBlock.tagName()))
162// {
163// QString number = domBlock.tagName();
164// number.remove(QRegExp("[\\D]*"));
165// domBlock.setTagName("BlockSubstitutions");
166// this->_subBlocks.push_back(new BlockSubstitutions(project,domBlock));
167// }
168// domBlock = domBlock.nextSiblingElement();
169// }
170
171 loadOptimValuesFromFrontFile(savVersion);
172
173
174// // Filling recomputed values from folder point_ (csv)
175// this->updateRecomputedPointsFromFolder();
176}
177
178void OptimResult::loadOptimValuesFromFrontFile(int version)
179{
180 switch(version)
181 {
182 case 0:
183 return loadOptimValuesFromFrontFilev0();
184 case 1:
185 return loadOptimValuesFromFrontFilev1();
186 default:
187 return;
188 }
189}
190
191void OptimResult::loadOptimValuesFromFrontFilev0()
192{
193 // Filling and Sizing recomputed variables (without values)
194 ModelPlus* curModel;
195 Optimization* problem = dynamic_cast<Optimization*>(_problem);
196 for(int iM=0;iM<_models.size();iM++)
197 {
198 curModel = omProject()->modelPlus(_models.at(iM));
199
200 if(curModel->variables()->isEmpty() && curModel->isCompiled(problem->ctrl(_models.at(iM))))
201 curModel->readVariables(problem->ctrl(_models.at(iM)),problem->filesToCopy());
202
203 for (int i=0;i<curModel->variables()->size();i++)
204 {
205 this->recomputedVariables()->addItem(new VariableResult(*curModel->variables()->at(i)));
206 }
207 }
208
209 // Filling final values from frontFile (csv)
210 QFileInfo frontFileInfo(saveFolder(),this->_optVarsFrontFileName);
211 if(frontFileInfo.exists())
212 updateOptimValuesFromFrontFile(frontFileInfo.absoluteFilePath());
213}
214
215void OptimResult::loadOptimValuesFromFrontFilev1()
216{
217 // this time, values are directly created from csv file
218 // Filling final values from frontFile (csv)
219
220 // read csv file
221 QFileInfo frontFileInfo(saveFolder(),this->_allVarsFrontFileName);
222 QFile frontFile(frontFileInfo.absoluteFilePath());
223 if(!frontFile.exists())
224 return;
225
226 frontFile.open(QIODevice::ReadOnly);
227 QTextStream tsfront( &frontFile );
228 QString text = tsfront.readAll();
229 frontFile.close();
230
231 // set recomputedvariables values from it
232 bool useScan = (dynamic_cast<Optimization*>(this->problem())->nbScans()>1);
233 this->recomputedVariables()->setUseScan(useScan);
234 this->recomputedVariables()->setFromCsv(text);
235
236
237 // update objectives and variables from it
238 // Clearing previous values
239 QString modelName,varName;
240 VariableResult* corrVar;
241 for (int i=0; i<this->optObjectivesResults()->size(); i++)
242 {
243 modelName = this->optObjectivesResults()->at(i)->model();
244 varName = this->optObjectivesResults()->at(i)->name(Variable::SHORT);
245 corrVar = this->recomputedVariables()->findVariable(modelName,varName);
246 if(corrVar)
247 this->optObjectivesResults()->replaceAt(i,corrVar->clone());
248 }
249
250 for (int i=0; i<this->optVariablesResults()->size(); i++)
251 {
252 modelName = this->optVariablesResults()->at(i)->model();
253 varName = this->optVariablesResults()->at(i)->name(Variable::SHORT);
254 corrVar = this->recomputedVariables()->findVariable(modelName,varName);
255 if(corrVar)
256 this->optVariablesResults()->replaceAt(i,corrVar->clone());
257 }
258}
259
260
261OptimResult::OptimResult(const OptimResult &res)
262 :Result(res)
263{
264 _algo = res._algo->clone();
265
266 _optVariablesResults = res._optVariablesResults->clone();
267 _optObjectivesResults = res._optObjectivesResults->clone();
268 _recomputedVariables = res._recomputedVariables->clone();
269
270 _curScan = res._curScan;
271 _curPoint = res._curPoint;
272
273 _optVarsFrontFileName = res._optVarsFrontFileName;
274 _allVarsFrontFileName = res._allVarsFrontFileName;
275}
276
277OptimResult::~OptimResult(void)
278{
279 delete _optVariablesResults;
280 delete _optObjectivesResults;
281 delete _recomputedVariables;
282 if(_algo)
283 delete _algo;
284}
285
286void OptimResult::updateOptimValuesFromFrontFile(QString fileName)
287{
288 QFile frontFile(fileName);
289 if(!frontFile.exists())
290 {
291 return;
292 }
293 frontFile.open(QIODevice::ReadOnly);
294 QTextStream tsfront( &frontFile );
295 QString text = tsfront.readAll();
296 frontFile.close();
297
298 // Clearing previous values
299 for (int i=0; i<this->optObjectivesResults()->size(); i++)
300 {
301 this->optObjectivesResults()->at(i)->clearFinalValues();
302 }
303 for (int i=0; i<this->optVariablesResults()->size(); i++)
304 {
305 this->optVariablesResults()->at(i)->clearFinalValues();
306 }
307 for (int i=0; i<this->recomputedVariables()->size(); i++)
308 {
309 this->recomputedVariables()->at(i)->clearFinalValues();
310 }
311
312 QStringList lines = text.split("\n",QString::KeepEmptyParts);
313
314 QStringList firstLine = lines[0].split("\t",QString::SkipEmptyParts);
315 int nbCols = firstLine.size();
316
317 QList<VariableResult *> objs;
318 QList<VariableResult*> optVars;
319 QList<VariableResult*> recompVars;
320
321 bool useScan = (dynamic_cast<Optimization*>(this->problem())->nbScans()>1);
322 this->recomputedVariables()->setUseScan(useScan);
323
324 // Filling index tables
325 for(int i=0; i<nbCols; i++)
326 {
327 objs.push_back(this->optObjectivesResults()->findItem(firstLine.at(i)));
328 optVars.push_back(this->optVariablesResults()->findItem(firstLine.at(i)));
329 if(!useScan)
330 recompVars.push_back(this->recomputedVariables()->findItem(firstLine.at(i)));
331 }
332
333 int iiSubBlock = firstLine.indexOf("subBlocksIndex");
Value stored to 'iiSubBlock' during its initialization is never read
334
335 // Filling variables and objectives values
336 QStringList curLine;
337 int iPoint=0;
338 int curIndex = 0; // to skip empty, partial or comment lines
339 for (int iLine = 1; iLine<lines.size(); iLine++)
340 {
341 curLine = lines[iLine].split("\t",QString::SkipEmptyParts);
342
343 if(curLine.size()==nbCols)
344 {
345 for (int iCol = 0; iCol < nbCols; iCol++)
346 {
347 if (objs[iCol])
348 {
349 objs[iCol]->setFinalValue(0,iPoint,curLine[iCol].toDouble());
350 }
351 if (optVars.at(iCol))
352 {
353 optVars.at(iCol)->setFinalValue(0,iPoint,curLine[iCol].toDouble());
354 }
355 if ((!useScan) && recompVars.at(iCol))
356 {
357 recompVars.at(iCol)->setFinalValue(0,iPoint,curLine[iCol].toDouble());
358 }
359 }
360
361// if(iiSubBlock>-1)
362// this->_iSubModels.push_back(curLine[iiSubBlock].toInt());
363
364 curIndex ++;
365 iPoint++;
366 }
367 }
368 }
369
370//void OptimResult::updateRecomputedPointsFromFolder()
371//{
372// _recomputedPoints.clear();
373
374// // Filling final values from frontFile (csv)
375// QDir dir(this->saveFolder());
376
377// // Looking for recomputed points
378// QString pointFolder;
379
380// VariableResult *newVariableResult;
381// bool curPointIsRecomputed;
382// int nbPoints = _optObjectivesResults->nbPoints();
383
384// for(int iPoint=0;iPoint<nbPoints;iPoint++)
385// {
386// pointFolder = dir.absolutePath()+ QDir::separator()+"point_"+QString::number(iPoint);
387// curPointIsRecomputed=dir.exists(pointFolder);
388
389
390// if(curPointIsRecomputed)
391// {
392// _recomputedPoints.push_back(iPoint);
393// _recomputedVariables->updateFromCsv(_recomputedVariables,iPoint,pointFolder+QDir::separator()+"resultVar.csv");
394// }
395// }
396//}
397
398
399
400QString OptimResult::buildOptVarsFrontCSV(QString separator)
401{
402 if(_optVariablesResults->size()==0)
403 return QString();
404
405 int nbPoints = _optVariablesResults->at(0)->nbPoints();
406 QList<int> listPoints;
407 for(int i=0;i<nbPoints;i++)
408 listPoints.push_back(i);
409
410 // concatenate variables concerned
411 MOOptVector variables(false,true,true,this);
412
413 variables.append(*_optObjectivesResults,false);
414 variables.append(*_optVariablesResults,false);
415
416 return buildVarsFrontCSV(&variables,listPoints,separator);
417}
418
419QString OptimResult::buildAllVarsFrontCSV(QString separator)
420{
421 if(_recomputedVariables->size()==0)
422 return QString();
423
424 int nbPoints = _recomputedVariables->at(0)->nbPoints();
425 QList<int> listPoints;
426 for(int i=0;i<nbPoints;i++)
427 listPoints.push_back(i);
428
429 return buildVarsFrontCSV(_recomputedVariables,listPoints,separator);
430}
431
432QString OptimResult::buildAllVarsFrontCSV(QList<int> listPoints,QString separator)
433{
434 if(_recomputedVariables->size()==0)
435 return QString();
436
437 return buildVarsFrontCSV(_recomputedVariables,listPoints,separator);
438}
439
440QString OptimResult::buildVarsFrontCSV(MOOptVector* variables, QList<int> listPoints,QString separator)
441{
442 return variables->toCSV(separator,listPoints);
443}
444
445QDomElement OptimResult::toXmlData(QDomDocument & doc)
446{
447 // Result element
448 QDomElement cRoot = doc.createElement("OMResult");
449 QDomElement cResult = doc.createElement(OptimResult::className());
450 cRoot.appendChild(cResult);
451
452
453 // Result definition
454 QDomElement cInfos = doc.createElement("Infos");
455 cInfos.setAttribute("name", name());
456 //cInfos.setAttribute("type", problemType());
457 cInfos.setAttribute("date", _date.toString());
458 cInfos.setAttribute("duration", _duration.toString());
459 cInfos.setAttribute("version", 1);
460 cResult.appendChild(cInfos);
461
462// // SubModels blocks
463// QDomElement cAllBlocks = doc.createElement("AllBlockSubstitutions");
464// for(int i=0;i<_subBlocks.size();i++)
465// {
466// QDomElement cBlocks = _subBlocks.at(i)->toXmlData(doc);
467// cBlocks.setTagName("BlockSubstitutions"+QString::number(i));
468// cAllBlocks.appendChild(cBlocks);
469// }
470// cResult.appendChild(cAllBlocks);
471
472
473 // Front File (containing values on pareto curve)
474 QDomElement cOptFrontFile = doc.createElement("OptVarsFrontFile");
475 cOptFrontFile.setAttribute("path", _optVarsFrontFileName);
476 cResult.appendChild(cOptFrontFile);
477 QDomElement cAllFrontFile = doc.createElement("AllVarsFrontFile");
478 cAllFrontFile.setAttribute("path", _allVarsFrontFileName);
479 cResult.appendChild(cAllFrontFile);
480
481
482 return cResult;
483
484}
485
486
487void OptimResult::setCurPoint(int curPoint)
488{
489 _curPoint = curPoint;
490
491 _recomputedVariables->setCurPoint(curPoint);
492 _optVariablesResults->setCurPoint(curPoint);
493 _optObjectivesResults->setCurPoint(curPoint);
494
495 emit curPointChanged();
496}
497
498void OptimResult::setCurScan(int curScan)
499{
500 _curScan = curScan;
501
502 _recomputedVariables->setCurScan(curScan );
503 _optVariablesResults->setCurScan(curScan );
504 _optObjectivesResults->setCurScan(curScan );
505
506 emit curPointChanged();
507}
508
509int OptimResult::curPoint()
510{
511 return _curPoint;
512}
513
514
515void OptimResult::exportFrontCSV(QString fileName, bool allVars)
516{
517 QString csv;
518 if(allVars)
519 csv = buildAllVarsFrontCSV();
520 else
521 csv = buildOptVarsFrontCSV();
522
523 QFile frontFile(fileName);
524 if(frontFile.exists())
525 frontFile.remove();
526
527 frontFile.open(QIODevice::WriteOnly);
528 QTextStream tsfront( &frontFile );
529 tsfront << csv;
530 frontFile.close();
531}
532
533void OptimResult::recomputePoints(QList<int> iPoints,bool forceRecompute)
534{
535
536 Optimization* problem = dynamic_cast<Optimization*>(_problem);
537
538 int iPoint;
539 int nbPoints = iPoints.size();
540
541 //Info
542 InfoSender::instance()->send( Info(ListInfo::RECOMPUTINGPOINTS,QString::number(nbPoints)));
543
544 //Execution
545 QString resultFolder = this->saveFolder();
546 QString pointSaveFolder;
547
548 for(int i=0;i<nbPoints;i++)
549 {
550 iPoint = iPoints.at(i);
551
552
553 if (!this->recomputedPoints().contains(iPoint) || forceRecompute)
554 {
555
556 //****************************************************
557 //Deleting point dir
558 //****************************************************
559 pointSaveFolder = resultFolder+QDir::separator()+"point_"+QString::number(iPoint);
560 QDir dir = QDir(pointSaveFolder);
561 // if dir already exists, deleting it
562 if (dir.exists())
563 {
564 bool removed,tempBool;
565
566 QStringList files = dir.entryList();
567 QString provFile;
568 for (int indf=0;indf<files.size();indf++)
569 {
570 provFile = files[indf];
571 tempBool = dir.remove(provFile);
572 }
573 bool temp = dir.cdUp();
574 dir.refresh();
575 removed = dir.rmdir(pointSaveFolder);
576 if (!removed)
577 {
578 InfoSender::instance()->send (Info(ListInfo::FOLDERUNREMOVABLE,pointSaveFolder));
579 }
580 }
581
582 for(int iM=0;iM<problem->models().size();iM++)
583 {
584 //*************************************************************
585 //Creating a new OneSimulation problem based on same model
586 //and specifying overwrited variables from optimized variable values
587 //*************************************************************
588 ModelPlus* modelPlus = omProject()->modelPlus(problem->models().at(iM));
589 OneSimulation *oneSim = new OneSimulation(omProject(),modelPlus);
590 oneSim->setCtrls(*problem->ctrls(problem->models().at(iM)));
591 Variable* overVar;
592 for(int iOverVar=0;iOverVar < this->optVariablesResults()->size();iOverVar++)
593 {
594 overVar = new Variable(*optVariablesResults()->at(iOverVar));
595// for(int iField=0;iField<Variable::nbFields;iField++)
596// {
597// overVar->setFieldValue(iField,this->optVariablesResults()->at(iOverVar)->getFieldValue(iField));
598// }
599 overVar->setFieldValue(Variable::VALUE,this->optVariablesResults()->at(iOverVar)->finalValue(0,iPoint));
600 oneSim->overwritedVariables()->addItem(overVar);
601 }
602
603 // Add scannedVariables
604 oneSim->scannedVariables()->cloneFromOtherVector(problem->scannedVariables());
605
606 // Add overwrited variables
607 for(int iV=0;iV<problem->overwritedVariables()->size();iV++)
608 oneSim->overwritedVariables()->addItem(problem->overwritedVariables()->at(iV)->clone());
609
610 //****************************************************
611 // Launch simulation
612 //****************************************************
613 ProblemConfig config;
614 OneSimResult *oneSimRes = dynamic_cast<OneSimResult*>(oneSim->launch(config));
615
616 if(!oneSimRes->isSuccess())
617 {
618 InfoSender::instance()->send( Info(ListInfo::RECOMPUTINGPOINTFAILED,QString::number(iPoint)));
619 }
620 else
621 {
622 InfoSender::instance()->send( Info(ListInfo::RECOMPUTINGPOINTSUCCESS,QString::number(iPoint)));
623
624 //****************************************************
625 // Filing recomputedVariables values
626 //****************************************************
627 VariableResult* newVariableResult;
628 VariableResult* curFinalVariable;
629 VariableResult* recVar;
630 for(int iVar=0;iVar<oneSimRes->finalVariables()->size();iVar++)
631 {
632 curFinalVariable = oneSimRes->finalVariables()->at(iVar);
633 // look in recomputed variables
634 recVar = this->recomputedVariables()->findItem(curFinalVariable->name());
635 if(recVar)
636 {
637 recVar->setFinalValuesAtPoint(iPoint,curFinalVariable->finalValuesAtPoint(0));
638 }
639 else
640 {
641 // copy from a Variable cast to avoid finalValues copying
642 newVariableResult = new VariableResult(*dynamic_cast<Variable*>(curFinalVariable));
643 newVariableResult->setFinalValuesAtPoint(iPoint,
644 curFinalVariable->finalValuesAtPoint(0));
645 this->recomputedVariables()->addItem(newVariableResult);
646
647 }
648 // update objective value if necessary (should'nt be the case, but if model has changed)
649 VariableResult* objVar= this->optObjectivesResults()->findItem(curFinalVariable->name());
650 if(objVar)
651 {
652 bool objOk=false;
653 OptObjective* optObj = problem->objectives()->findItem(objVar->name());
654 if(optObj)
655 {
656 double objValue = VariablesManip::calculateObjValue(optObj,oneSimRes->finalVariables(),objOk);
657 objVar->setFinalValue(0,iPoint,objValue,objOk);
658 }
659 }
660 }
661// //*****************************
662// //Saving results into csv file
663// //*****************************
664// //update scan folders
665// LowTools::mkpath(pointSaveFolder,true);
666// QFile file(pointSaveFolder+QDir::separator()+"resultVar.csv");
667// file.open(QIODevice::WriteOnly);
668// QTextStream ts( &file );
669// ts << CSVBase::variableResultToValueLines(this->recomputedVariables(),iPoint);
670// file.close();
671
672 delete oneSimRes;
673 }
674 }
675 }
676 else
677 {
678 QString msg = "Point " + QString::number(iPoint)+" already computed. Won't be recomputed";
679 InfoSender::instance()->send(Info(msg,ListInfo::NORMAL2));
680 }
681 }
682
683 emit finishedRecomputingPoints(iPoints);
684}
685
686int OptimResult::nbPoints()
687{
688 return _optVariablesResults->nbPoints();
689}
690