688 lines
26 KiB
C++
688 lines
26 KiB
C++
|
||
#include <iostream>
|
||
#include <fstream>
|
||
#include <sstream>
|
||
#include <cmath>
|
||
#include <QLabel>
|
||
#include <QString>
|
||
#include <QThread>
|
||
#include "QtConcurrent/qtconcurrentrun.h"
|
||
#include "manager.h"
|
||
|
||
enum Group {CM, PM, CN, PN};
|
||
static const bool multipleThreads = true;
|
||
static const int nThreads = 4;
|
||
static const bool blackAndWhite = false;
|
||
|
||
/*
|
||
* Конструктор
|
||
*/
|
||
Manager::Manager(QObject *parent) : manItem(0),
|
||
xCoord(100, 0), yCoord(100, 0), cowardMedian(0), cowardNormal(0), protectorMedian(0), protectorNormal(0),
|
||
agentRadius(0), speedDistr(0), gamerSpeed(0), period(0), initDistr(0), enmity(0), newEnmity(0),
|
||
viewOrPackageMode(0), nIterations(1), nModels(1), outputToTxt(false), typeContentment(0), radiusLocality(0), QObject(parent)
|
||
{
|
||
window = new QWidget;
|
||
base = new QGridLayout;
|
||
QGroupBox *settings = new QGroupBox;
|
||
initSettings(settings);
|
||
tabWindow = new QTabWidget;
|
||
initTab(tabWindow);
|
||
|
||
base->addWidget(settings, 0, 1);
|
||
base->addWidget(tabWindow, 0, 0);
|
||
|
||
window->setLayout(base);
|
||
window->setWindowTitle("Agressor-Protector");
|
||
window->show();
|
||
|
||
// создание таймера
|
||
timer = new QTimer(this);
|
||
timer->setInterval(1000/10);
|
||
timer->stop();
|
||
|
||
// хранитель данных
|
||
history = new APHistory(); // ToDo: setNModel
|
||
}
|
||
|
||
/*
|
||
* Создание окна настроек
|
||
*/
|
||
void Manager::initSettings(QGroupBox *set){
|
||
QVBoxLayout *box = new QVBoxLayout;
|
||
|
||
QGroupBox *box1 = new QGroupBox;
|
||
QGroupBox *box2 = new QGroupBox;
|
||
QGroupBox *box3 = new QGroupBox;
|
||
QGroupBox *box4 = new QGroupBox;
|
||
QGroupBox *box5 = new QGroupBox;
|
||
|
||
QGridLayout *hbox1 = new QGridLayout;
|
||
QGridLayout *hbox2 = new QGridLayout;
|
||
QGridLayout *hbox3 = new QGridLayout;
|
||
QGridLayout *hbox4 = new QGridLayout;
|
||
QVBoxLayout *hbox5 = new QVBoxLayout;
|
||
|
||
QLabel *labelMode1 = new QLabel("Gamer is a coward");
|
||
QLabel *labelMode2 = new QLabel("Gamer is a protector");
|
||
QLabel *labelStrategy1 = new QLabel("Along median");
|
||
QLabel *labelStrategy2 = new QLabel("Along normal");
|
||
QSpinBox *spinCM = new QSpinBox;
|
||
spinCM->setMaximum(1000);
|
||
connect (spinCM, SIGNAL(valueChanged(int)), this, SLOT(setCowardMedian(int)));
|
||
QSpinBox *spinCN = new QSpinBox;
|
||
spinCN->setMaximum(1000);
|
||
connect (spinCN, SIGNAL(valueChanged(int)), this, SLOT(setCowardNormal(int)));
|
||
QSpinBox *spinPM = new QSpinBox;
|
||
spinPM->setMaximum(1000);
|
||
connect (spinPM, SIGNAL(valueChanged(int)), this, SLOT(setProtectorMedian(int)));
|
||
QSpinBox *spinPN = new QSpinBox;
|
||
spinPN->setMaximum(1000);
|
||
connect (spinPN, SIGNAL(valueChanged(int)), this, SLOT(setProtectorNormal(int)));
|
||
|
||
QLabel *labelRadius = new QLabel("Gamer radius:");
|
||
QSpinBox *boxRadius = new QSpinBox;
|
||
connect(boxRadius, SIGNAL(valueChanged(int)), this, SLOT(setAgentRadius(int)));
|
||
QLabel *labelEnmity = new QLabel("Enmity:");
|
||
QSpinBox *spinBoxEnmity = new QSpinBox;
|
||
connect(spinBoxEnmity, SIGNAL(valueChanged(int)), this, SLOT(setNewEnmity(int)));
|
||
// QLabel *labelSpeedDistr = new QLabel("Speed distribution:");
|
||
// QComboBox *comboSpeedDistr = new QComboBox;
|
||
// comboSpeedDistr->addItem("homogeneous");
|
||
QLabel *labelSpeed = new QLabel("Gamer speed:");
|
||
QSpinBox *spinSpeed = new QSpinBox;
|
||
spinSpeed->setMaximum(10);
|
||
connect(spinSpeed, SIGNAL(valueChanged(int)), this, SLOT(setGamerSpeed(int)));
|
||
QLabel *labelCont = new QLabel("Type of contenment calculation: ");
|
||
QComboBox *comboContent = new QComboBox;
|
||
comboContent->addItem("absolute");
|
||
comboContent->addItem("comparative");
|
||
connect(comboContent, SIGNAL(currentIndexChanged(int)), this, SLOT(setTypeContenment(int)));
|
||
QLabel *labelLocality = new QLabel("Radius of locality");
|
||
spinLocality = new QSpinBox;
|
||
spinLocality->setEnabled(false);
|
||
connect(spinLocality, SIGNAL(valueChanged(int)), this, SLOT(setRadiusLocality(int)));
|
||
connect(comboContent, SIGNAL(currentIndexChanged(int)), this, SLOT(manageSpinLocality(int)));
|
||
|
||
QCheckBox *checkPeriod = new QCheckBox;
|
||
checkPeriod->setText("Periodicity");
|
||
connect(checkPeriod, SIGNAL(toggled(bool)), this, SLOT(setPeriodicity(bool)));
|
||
QLabel *label = new QLabel("Initial distribution:");
|
||
QComboBox *comboDistr = new QComboBox;
|
||
comboDistr->addItem("random");
|
||
comboDistr->addItem("on the circle");
|
||
connect(comboDistr, SIGNAL(currentIndexChanged(int)), this, SLOT(setDistr(int)));
|
||
|
||
createButton = new QPushButton;
|
||
createButton->setText("Create");
|
||
connect(createButton, SIGNAL(clicked()), this, SLOT(resetProgressBarAndHistory()));
|
||
connect(createButton, SIGNAL(clicked()), this, SLOT(initModel()));
|
||
|
||
QLabel *labelViewOrPackage = new QLabel("Type of job: ");
|
||
viewOrPackage = new QComboBox;
|
||
viewOrPackage->addItem("one model in detail");
|
||
viewOrPackage->addItem("processing");
|
||
connect(viewOrPackage, SIGNAL(currentIndexChanged(int)), this, SLOT(setviewOrPackageMode(int)));
|
||
connect(viewOrPackage, SIGNAL(currentIndexChanged(int)), this, SLOT(managePackageOptions(int)));
|
||
checkLink = new QCheckBox;
|
||
checkLink->setText("Show links");
|
||
checkOutputToTxt = new QCheckBox;
|
||
checkOutputToTxt->setText("Output to txt");
|
||
connect(checkOutputToTxt, SIGNAL(toggled(bool)), this, SLOT(setOutputToTxt(bool)));
|
||
QLabel *label3 = new QLabel("Updating frequency: ");
|
||
comboTime = new QComboBox;
|
||
comboTime->addItem("1000/10");
|
||
comboTime->addItem("1000/20");
|
||
comboTime->addItem("1000/30");
|
||
comboTime->addItem("1000/50");
|
||
comboTime->addItem("1000/100");
|
||
connect(comboTime, SIGNAL(currentIndexChanged(int)), this, SLOT(timerRestart(int)));
|
||
QLabel *labelIterations = new QLabel("Number of iterations: ");
|
||
spinIterations = new QSpinBox;
|
||
spinIterations->setMinimum(1);
|
||
spinIterations->setMaximum(10000);
|
||
spinIterations->setEnabled(false);
|
||
connect(spinIterations, SIGNAL(valueChanged(int)), this, SLOT(setNIterations(int)));
|
||
QLabel *labelModels = new QLabel("Number of models: ");
|
||
spinModels = new QSpinBox;
|
||
spinModels->setMinimum(1);
|
||
spinModels->setMaximum(1000);
|
||
spinModels->setEnabled(false);
|
||
connect(spinModels, SIGNAL(valueChanged(int)), this, SLOT(setNModels(int)));
|
||
buttonTime = new QPushButton;
|
||
buttonTime->setText("Start");
|
||
connect(buttonTime, SIGNAL(clicked()), this, SLOT(handleButton()));
|
||
buttonTime->setEnabled(false);
|
||
|
||
hbox1->addWidget(labelMode1, 0, 1);
|
||
hbox1->addWidget(labelMode2, 0, 2);
|
||
hbox1->addWidget(labelStrategy1, 1, 0);
|
||
hbox1->addWidget(labelStrategy2, 2, 0);
|
||
hbox1->addWidget(spinCM, 1, 1);
|
||
hbox1->addWidget(spinCN, 2, 1);
|
||
hbox1->addWidget(spinPM, 1, 2);
|
||
hbox1->addWidget(spinPN, 2, 2);
|
||
box1->setLayout(hbox1);
|
||
box1->setTitle("Gamers number");
|
||
|
||
hbox2->addWidget(labelRadius, 0, 0);
|
||
hbox2->addWidget(boxRadius, 0, 1);
|
||
hbox2->addWidget(labelEnmity, 1, 0);
|
||
hbox2->addWidget(spinBoxEnmity, 1, 1);
|
||
// hbox2->addWidget(labelSpeedDistr, 2, 0);
|
||
// hbox2->addWidget(comboSpeedDistr, 2, 1);
|
||
hbox2->addWidget(labelSpeed, 3, 0);
|
||
hbox2->addWidget(spinSpeed, 3, 1);
|
||
hbox2->addWidget(labelCont, 4, 0);
|
||
hbox2->addWidget(comboContent, 4, 1);
|
||
hbox2->addWidget(labelLocality, 5, 0);
|
||
hbox2->addWidget(spinLocality, 5, 1);
|
||
box2->setLayout(hbox2);
|
||
box2->setTitle("Gamer settings");
|
||
|
||
hbox3->addWidget(checkPeriod, 0, 0);
|
||
hbox3->addWidget(label, 1, 0);
|
||
hbox3->addWidget(comboDistr, 1, 1);
|
||
box3->setLayout(hbox3);
|
||
box3->setTitle("Scene settings");
|
||
|
||
hbox4->addWidget(labelViewOrPackage, 0, 0);
|
||
hbox4->addWidget(viewOrPackage, 0, 1);
|
||
hbox4->addWidget(checkLink, 1, 0);
|
||
hbox4->addWidget(checkOutputToTxt, 1, 1);
|
||
hbox4->addWidget(label3, 2, 0);
|
||
hbox4->addWidget(comboTime, 2, 1);
|
||
hbox4->addWidget(labelIterations, 3, 0);
|
||
hbox4->addWidget(spinIterations, 3, 1);
|
||
hbox4->addWidget(labelModels, 4, 0);
|
||
hbox4->addWidget(spinModels, 4, 1);
|
||
box4->setLayout(hbox4);
|
||
|
||
hbox5->addWidget(createButton);
|
||
hbox5->addWidget(buttonTime);
|
||
box5->setLayout(hbox5);
|
||
|
||
box->addWidget(box1);
|
||
box->addWidget(box2);
|
||
box->addWidget(box3);
|
||
box->addWidget(box4);
|
||
box->addWidget(box5);
|
||
box->addStretch();
|
||
|
||
set->setLayout(box);
|
||
}
|
||
|
||
void Manager::initTab(QTabWidget *tabs){
|
||
// Первая вкладка - визуализация одной модели (сцена + график)
|
||
QWidget *viewTab = new QWidget;
|
||
QGridLayout *viewLayout = new QGridLayout;
|
||
// Создание и заполнение сцены
|
||
scene = new QGraphicsScene;
|
||
scene->setSceneRect(-300, -300, 600, 600);
|
||
scene->setItemIndexMethod(QGraphicsScene::NoIndex);
|
||
|
||
QGraphicsView *view = new QGraphicsView(scene);
|
||
view->setRenderHint(QPainter::Antialiasing);
|
||
view->setCacheMode(QGraphicsView::CacheBackground);
|
||
view->resize(800, 800);
|
||
view->setMinimumWidth(600);
|
||
view->show();
|
||
|
||
// Создание графика ср.неудовлетворённости
|
||
QLabel *labelGraph = new QLabel("Dynamics of average contenment");
|
||
labelContent = new QLabel("Average contentment: ");
|
||
plot = new QCustomPlot;
|
||
plot->addGraph();
|
||
for (int i = 0; i < 100; i++)
|
||
{
|
||
xCoord[i] = i;
|
||
}
|
||
plot->graph(0)->setData(xCoord, yCoord);
|
||
plot->yAxis->setRange(0, 1);
|
||
plot->graph(0)->rescaleAxes();
|
||
plot->yAxis->setVisible(false);
|
||
plot->xAxis->setTickLabels(false);
|
||
|
||
viewLayout->addWidget(view, 0, 0, 1, 2);
|
||
viewLayout->addWidget(labelGraph, 1, 0);
|
||
viewLayout->addWidget(labelContent, 1, 1);
|
||
viewLayout->addWidget(plot, 2, 0, 1, 2);
|
||
|
||
viewTab->setLayout(viewLayout);
|
||
|
||
// Вторая вкладка - пакетное задание (прогресс-бар)
|
||
QWidget *packageTab = new QWidget;
|
||
QGridLayout *packageLayout = new QGridLayout;
|
||
|
||
prBar = new QProgressBar;
|
||
prBar->setValue(0);
|
||
QLabel *graphComboLabel = new QLabel("Compose the graphic for: ");
|
||
graphCombo = new QComboBox;
|
||
graphCombo->setEnabled(false);
|
||
graphCombo->addItem("---");
|
||
connect(graphCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(composeGraph(int)));
|
||
|
||
batchPlot = new QCustomPlot;
|
||
batchPlot->addGraph();
|
||
batchPlot->addGraph();
|
||
batchPlot->addGraph();
|
||
batchPlot->addGraph();
|
||
batchPlot->addGraph();
|
||
batchPlot->graph(0)->setPen(QPen(Qt::black, 2));
|
||
if (blackAndWhite) {
|
||
batchPlot->graph(CM + 1)->setPen(QPen(Qt::SolidLine));
|
||
batchPlot->graph(PM + 1)->setPen(QPen(Qt::DashDotLine));
|
||
batchPlot->graph(CN + 1)->setPen(QPen(Qt::DashLine));
|
||
QPen * pen = new QPen(QPen(Qt::DashDotDotLine));
|
||
pen->setWidth(2);
|
||
batchPlot->graph(PN + 1)->setPen(*pen);
|
||
} else {
|
||
batchPlot->graph(CM + 1)->setPen(QPen(Qt::red));
|
||
batchPlot->graph(PM + 1)->setPen(QPen(Qt::yellow));
|
||
batchPlot->graph(CN + 1)->setPen(QPen(Qt::darkBlue));
|
||
batchPlot->graph(PN + 1)->setPen(QPen(Qt::cyan));
|
||
}
|
||
batchPlot->graph(0)->setName("Average for all agents");
|
||
batchPlot->graph(CM + 1)->setName("Average for coward-median");
|
||
batchPlot->graph(PM + 1)->setName("Average for all protector-median");
|
||
batchPlot->graph(CN + 1)->setName("Average for all coward-normal");
|
||
batchPlot->graph(PN + 1)->setName("Average for all protector-normal");
|
||
|
||
xBatchCoord.resize(100);
|
||
yBatchCoord.resize(100);
|
||
yBatchCoord.fill(0);
|
||
for (int i = 0; i < 100; i++)
|
||
{
|
||
xBatchCoord[i] = i;
|
||
}
|
||
batchPlot->graph(0)->setData(xBatchCoord, yBatchCoord);
|
||
batchPlot->yAxis->setRange(0, 1.05);
|
||
QVector<qreal> ticks;
|
||
qreal i = 0;
|
||
while (i <= 1.05) {
|
||
ticks << i;
|
||
i += 0.1;
|
||
}
|
||
batchPlot->yAxis->setAutoTicks(false);
|
||
batchPlot->yAxis->setTickVector(ticks);
|
||
batchPlot->graph(0)->rescaleAxes();
|
||
|
||
QLabel *labelSaveWithName = new QLabel("Save with name: ");
|
||
lineSaveWithName = new QLineEdit;
|
||
lineSaveWithName->setPlaceholderText("For example: default_name");
|
||
QPushButton *buttonSaveGraph = new QPushButton;
|
||
buttonSaveGraph->setText("Save as jpeg");
|
||
connect(buttonSaveGraph, SIGNAL(clicked()), this, SLOT(saveGragh()));
|
||
|
||
packageLayout->addWidget(prBar, 0, 0, 1, 2);
|
||
packageLayout->addWidget(graphComboLabel, 1, 0, 1, 1);
|
||
packageLayout->addWidget(graphCombo, 1, 1, 1, 1);
|
||
packageLayout->addWidget(batchPlot, 2, 0, 2, 2);
|
||
packageLayout->addWidget(labelSaveWithName, 4, 0, 1, 1);
|
||
packageLayout->addWidget(lineSaveWithName, 4, 1, 1, 1);
|
||
packageLayout->addWidget(buttonSaveGraph, 5, 1, 1, 1);
|
||
packageTab->setLayout(packageLayout);
|
||
|
||
tabs->addTab(viewTab, "One model in detail");
|
||
tabs->addTab(packageTab, "Batch processing");
|
||
connect(tabs, SIGNAL(currentChanged(int)), viewOrPackage, SLOT(setCurrentIndex(int)));
|
||
}
|
||
|
||
QVector<qreal> Manager::calculateAvContenmentForGroups(uint typeCalc, uint iModel){
|
||
qreal max = 0;
|
||
qreal res = 0;
|
||
QVector<qreal> cont(4, 0);
|
||
QList <Agent *> neibours;
|
||
QVector<uint> nAgents;
|
||
nAgents << cowardMedian << protectorMedian << cowardNormal << protectorNormal;
|
||
if (modelList[iModel]->getAgentList().size() == 0){
|
||
return cont;
|
||
}
|
||
// С оглядкой на всех агентов
|
||
else if (typeCalc == 0){
|
||
int ind = 0;
|
||
for (int i = 0; i < modelList[iModel]->getAgentList().size(); i++){
|
||
if (modelList[iModel]->getAgentList()[i]->getMode() == 0) {
|
||
ind = modelList[iModel]->getAgentList()[i]->getStrategy() == 0 ? 0 : 2;
|
||
}
|
||
else {
|
||
ind = modelList[iModel]->getAgentList()[i]->getStrategy() == 0 ? 1 : 3;
|
||
}
|
||
if (modelList[iModel]->getAgentList()[i]->getDistTarget() > max){
|
||
max = modelList[iModel]->getAgentList()[i]->getDistTarget();
|
||
}
|
||
else{}
|
||
if (max > 0.0) {
|
||
modelList[iModel]->getAgentList()[i]->setContentment(modelList[iModel]->getAgentList()[i]->getDistTarget()/max);
|
||
cont[ind] += modelList[iModel]->getAgentList()[i]->getDistTarget()/max;
|
||
}
|
||
else{
|
||
modelList[iModel]->getAgentList()[i]->setContentment(1);
|
||
cont[ind] += 1;
|
||
}
|
||
}
|
||
}
|
||
// С оглядкой на агентов внутри окрестности
|
||
else if (typeCalc == 1){
|
||
for (int i = 0; i < modelList[iModel]->getAgentList().size(); i++){
|
||
int ind = 0;
|
||
if (modelList[iModel]->getAgentList()[i]->getMode() == 0) {
|
||
ind = modelList[iModel]->getAgentList()[i]->getStrategy() == 0 ? 0 : 2;
|
||
}
|
||
else {
|
||
ind = modelList[iModel]->getAgentList()[i]->getStrategy() == 0 ? 1 : 3;
|
||
}
|
||
|
||
neibours = modelList[iModel]->DangerGamer(i, 0, 0, radiusLocality);
|
||
max = modelList[iModel]->getAgentList()[i]->getDistTarget();
|
||
for (int j = 0; j < neibours.size(); j++){
|
||
if (neibours[j]->getDistTarget() > max){
|
||
max = neibours[j]->getDistTarget();
|
||
}
|
||
else{}
|
||
}
|
||
if (max > 0.0) {
|
||
modelList[iModel]->getAgentList()[i]->setContentment(modelList[iModel]->getAgentList()[i]->getDistTarget()/max);
|
||
cont[ind] += modelList[iModel]->getAgentList()[i]->getDistTarget()/max;
|
||
}
|
||
else{
|
||
modelList[iModel]->getAgentList()[i]->setContentment(1);
|
||
cont[ind] += 1;
|
||
}
|
||
}
|
||
}
|
||
for (int i = CM; i < PN + 1; i++){
|
||
if (nAgents[i] != 0) {
|
||
res += cont[i];
|
||
cont[i] = cont[i]/nAgents[i];
|
||
}
|
||
}
|
||
modelList[iModel]->setAvContentment(res/modelList[iModel]->getAgentList().size());
|
||
yCoord.removeFirst();
|
||
yCoord.push_back(res/modelList[iModel]->getAgentList().size());
|
||
return cont;
|
||
}
|
||
|
||
/*
|
||
* Создание модели по полученным данным
|
||
*/
|
||
void Manager::initModel(){
|
||
|
||
buttonTime->setText("Start");
|
||
createButton->setText("Recreate");
|
||
|
||
yCoord.fill(0);
|
||
graphCombo->setCurrentIndex(0);
|
||
graphCombo->setEnabled(false);
|
||
|
||
// Визуализация одной модели
|
||
if (viewOrPackageMode == 0){
|
||
timer->stop();
|
||
history->addClassHistory();
|
||
history->addClassGroupHistory();
|
||
Model *model = new Model(0, cowardMedian, cowardNormal, protectorMedian, protectorNormal, agentRadius, gamerSpeed, period, initDistr, enmity, newEnmity);
|
||
modelList.push_back(model);
|
||
if (manItem != 0){
|
||
delete manItem;
|
||
}
|
||
batchPlot->clearItems();
|
||
batchPlot->replot();
|
||
// Создание управленца визуализацией
|
||
manItem = new ManagerItem(model->getAgentList(), scene, cowardMedian, cowardNormal, protectorMedian);
|
||
connect(timer, SIGNAL(timeout()), this, SLOT(timerEvent()));
|
||
connect(timer, SIGNAL(timeout()), manItem, SLOT(gameEvent()));
|
||
connect(checkLink, SIGNAL(toggled(bool)), manItem, SLOT(setLink(bool)));
|
||
}
|
||
// Пакетное задание
|
||
else {
|
||
// Очистка сцены и графика на первой вкладке
|
||
scene->clear();
|
||
plot->graph(0)->setData(xCoord, yCoord);
|
||
plot->replot();
|
||
|
||
prBar->setMinimum(0);
|
||
prBar->setMaximum(nIterations*nModels);
|
||
}
|
||
setEnmity(newEnmity);
|
||
buttonTime->setEnabled(true);
|
||
}
|
||
|
||
/*
|
||
* Событие игры. Вычисление новых координат для всех игроков на сцене
|
||
*/
|
||
void Manager::timerEvent(){
|
||
modelList[0]->modelIteration();
|
||
history->addGroupAvContenmentData(0, calculateAvContenmentForGroups(typeContentment, 0));
|
||
history->addAvContenmentData(0, modelList[0]->getAvContentment());
|
||
if (outputToTxt) {
|
||
history->postPrintModelData(0);
|
||
history->postPrintGroupData(0);
|
||
}
|
||
plot->graph(0)->setData(xCoord, yCoord);
|
||
plot->replot();
|
||
history->addGroupAvContenmentData(0, calculateAvContenmentForGroups(typeContentment, 0));
|
||
history->addAvContenmentData(0, modelList[0]->getAvContentment()); // запись в хранитель данных
|
||
labelContent->setText("Average contenment: " + QString::number(modelList[0]->getAvContentment()));
|
||
}
|
||
|
||
void Manager::iteration(uint j) {
|
||
Model *model = new Model(j, cowardMedian, cowardNormal, protectorMedian, protectorNormal, agentRadius, gamerSpeed, period, initDistr, enmity, newEnmity);
|
||
modelList.append(model);
|
||
for(int i = 0; i < nIterations; i++){
|
||
model->modelIteration();
|
||
history->addGroupAvContenmentData(modelList.indexOf(model), calculateAvContenmentForGroups(typeContentment, modelList.indexOf(model)));
|
||
history->addAvContenmentData(modelList.indexOf(model), model->getAvContentment());
|
||
//qApp->processEvents();
|
||
}
|
||
if (outputToTxt) {
|
||
history->postPrintModelData(modelList.indexOf(model));
|
||
history->postPrintGroupData(modelList.indexOf(model));
|
||
}
|
||
model->clear();
|
||
//delete model;
|
||
}
|
||
|
||
void Manager::handlePrBar() {
|
||
//prBar->setValue(prBar->value() + nIterations);
|
||
std::cout << "handlePrBar" << std::endl;
|
||
}
|
||
|
||
/*
|
||
* Остановка/возобновление игры
|
||
*/
|
||
void Manager::handleButton(){
|
||
// Визуализация модели
|
||
if(viewOrPackageMode == 0){
|
||
if (timer->isActive()){
|
||
timer->stop();
|
||
buttonTime->setText("Start");
|
||
}
|
||
else {
|
||
timer->start(timer->interval());
|
||
buttonTime->setText("Pause");
|
||
}
|
||
}
|
||
// Пакетное задание (без возможности остановки)
|
||
else{
|
||
buttonTime->setText("In process...");
|
||
buttonTime->setEnabled(false);
|
||
createButton->setEnabled(false);
|
||
tabWindow->setTabEnabled(0, false);
|
||
//prBar->setValue(0);
|
||
|
||
if(!multipleThreads){
|
||
for (int i = 0; i < nModels; i++) {
|
||
history->addClassHistory();
|
||
history->addClassGroupHistory();
|
||
iteration(i);
|
||
prBar->setValue(prBar->value() + nIterations);
|
||
}
|
||
}
|
||
else {
|
||
QVector<QFuture<void> > futureVector;
|
||
QVector<QFutureWatcher<void> *> watcherVector;
|
||
for (int i = 0; i < nThreads; i++) {
|
||
QFuture<void> future;
|
||
futureVector.append(future);
|
||
QFutureWatcher<void> *watcher = new QFutureWatcher<void>;
|
||
watcherVector.append(watcher);
|
||
//connect(watcherVector[i], SIGNAL(finished()), this, SLOT(handlePrBar()));
|
||
}
|
||
|
||
for(int i = 0; i < nModels; i++) {
|
||
history->addClassHistory();
|
||
history->addClassGroupHistory();
|
||
}
|
||
|
||
for(int j = 0; j < nModels/nThreads; j++){
|
||
for (int i = 0; i < nThreads; i++) {
|
||
//qApp->processEvents();
|
||
futureVector[i] = QtConcurrent::run(this, &Manager::iteration, j*nThreads + i);
|
||
watcherVector[i]->setFuture(futureVector[i]);
|
||
}
|
||
qApp->processEvents();
|
||
prBar->setValue(prBar->value() + nThreads*nIterations);
|
||
for (int i = 0; i < nThreads; i++) {
|
||
watcherVector[i]->waitForFinished();
|
||
//modelList[j*nThreads + i]->clear();
|
||
//prBar->setValue(prBar->value() + nIterations);
|
||
}
|
||
}
|
||
//qApp->processEvents();
|
||
if (nModels % nThreads != 0) {
|
||
for (int i = 0; i < nModels % nThreads; i++) {
|
||
futureVector[i] = QtConcurrent::run(this, &Manager::iteration, nThreads*(nModels/nThreads) + i);
|
||
watcherVector[i]->setFuture(futureVector[i]);
|
||
}
|
||
prBar->setValue(prBar->value() + (nModels % nThreads)*nIterations);
|
||
for (int i = 0; i < nModels % nThreads; i++) {
|
||
watcherVector[i]->waitForFinished();
|
||
//modelList[nThreads*(nModels/nThreads) + i]->clear();
|
||
//prBar->setValue(prBar->value() + nIterations);
|
||
}
|
||
}
|
||
}
|
||
qDeleteAll(modelList.begin(), modelList.end());
|
||
modelList.clear();
|
||
if (outputToTxt) {
|
||
history->postPrintGlobalAverage();
|
||
}
|
||
disconnect(graphCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(composeGraph(int)));
|
||
graphCombo->clear();
|
||
graphCombo->addItem("---");
|
||
for(int i = 0; i < nModels; i++){
|
||
QString comboString = "Model ";
|
||
comboString += QString::number(i + 1);
|
||
graphCombo->addItem(comboString);
|
||
}
|
||
if (nModels > 1) {
|
||
graphCombo->addItem("Average for all models");
|
||
}
|
||
connect(graphCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(composeGraph(int)));
|
||
buttonTime->setText("Start");
|
||
buttonTime->setEnabled(true);
|
||
graphCombo->setEnabled(true);
|
||
createButton->setEnabled(true);
|
||
tabWindow->setTabEnabled(0, true);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Перезапуск таймера
|
||
*/
|
||
void Manager::timerRestart(int index){
|
||
if (index == 0){
|
||
timer->setInterval(1000/10);
|
||
}
|
||
else if(index == 1){
|
||
timer->setInterval(1000/20);
|
||
}
|
||
else if(index == 2){
|
||
timer->setInterval(1000/30);
|
||
}
|
||
else if(index == 3){
|
||
timer->setInterval(1000/50);
|
||
}
|
||
else if (index == 4){
|
||
timer->setInterval(1000/100);
|
||
}
|
||
else{}
|
||
}
|
||
|
||
void Manager::resetProgressBarAndHistory(){
|
||
prBar->setValue(0);
|
||
history->clearHistory();
|
||
}
|
||
/*
|
||
* Вкл/выкл спинбокс для радиуса окрестности
|
||
*/
|
||
void Manager::manageSpinLocality(int value){
|
||
if (value == 0){
|
||
spinLocality->setEnabled(false);
|
||
}
|
||
else{
|
||
spinLocality->setEnabled(true);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Вкл/выкл спинбокс для числа итераций и спинбокс для числа запусков модели
|
||
*/
|
||
void Manager::managePackageOptions(int val){
|
||
if(val == 0){
|
||
spinIterations->setEnabled(false);
|
||
spinModels->setEnabled(false);
|
||
checkLink->setEnabled(true);
|
||
comboTime->setEnabled(true);
|
||
}
|
||
else {
|
||
timer->stop();
|
||
spinIterations->setEnabled(true);
|
||
spinModels->setEnabled(true);
|
||
checkLink->setEnabled(false);
|
||
comboTime->setEnabled(false);
|
||
}
|
||
tabWindow->setCurrentIndex(val);
|
||
}
|
||
|
||
void Manager::composeGraph(int iModel) {
|
||
xBatchCoord.resize(nIterations);
|
||
QVector<qreal> avCM(nIterations, 0);
|
||
QVector<qreal> avPM(nIterations, 0);
|
||
QVector<qreal> avCN(nIterations, 0);
|
||
QVector<qreal> avPN(nIterations, 0);
|
||
|
||
for(int i = 0; i < nIterations; i++) {
|
||
xBatchCoord[i] = i;
|
||
}
|
||
yBatchCoord.resize(nIterations);
|
||
batchPlot->xAxis->setRange(0, nIterations + 1);
|
||
if(iModel == 0) {
|
||
yBatchCoord.fill(0);
|
||
}
|
||
else if (iModel == nModels + 1){
|
||
yBatchCoord = history->getAverageForAllModels().toVector();
|
||
avCM = history->getAverageForGroup(CM).toVector();
|
||
avPM = history->getAverageForGroup(PM).toVector();
|
||
avCN = history->getAverageForGroup(CN).toVector();
|
||
avPN = history->getAverageForGroup(PN).toVector();
|
||
} else {
|
||
yBatchCoord = history->getHistory(iModel - 1).toVector();
|
||
avCM = history->getGroupHistory(iModel - 1, CM).toVector();
|
||
avPM = history->getGroupHistory(iModel - 1, PM).toVector();
|
||
avCN = history->getGroupHistory(iModel - 1, CN).toVector();
|
||
avPN = history->getGroupHistory(iModel - 1, PN).toVector();
|
||
}
|
||
batchPlot->graph(0)->setData(xBatchCoord, yBatchCoord);
|
||
batchPlot->graph(CM + 1)->setData(xBatchCoord, avCM);
|
||
batchPlot->graph(PM + 1)->setData(xBatchCoord, avPM);
|
||
batchPlot->graph(CN + 1)->setData(xBatchCoord, avCN);
|
||
batchPlot->graph(PN + 1)->setData(xBatchCoord, avPN);
|
||
batchPlot->legend->setVisible(true);
|
||
batchPlot->replot();
|
||
}
|
||
|
||
void Manager::saveGragh() {
|
||
batchPlot->saveJpg(lineSaveWithName->text() + ".jpg");
|
||
}
|