/home/enzo/treballs/fib/pfc/nanocomp/src/simulationManager.cpp

Go to the documentation of this file.

/*
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
                                                                          */

// $Revision: 1.12 $

#include "simulationManager.hpp"


SimulationManager::SimulationManager(MainController *controller, TruthTableManager *tableManager, ForbiddenPatternManager *FPManager, RuleManager *ruleManager, LayoutManager *layoutManager)
{
    this->tableManager = tableManager;
    this->FPManager = FPManager;
    this->ruleManager = ruleManager;
    this->controller = controller;
    this->layoutManager = layoutManager;
}


SimulationManager::~SimulationManager()
{
}



void SimulationManager::prepareSimulation()
{
    //Get the table, rules and patterns
    rules.clear();
    patterns.clear();
    table = *(layoutManager->getTableSelected());
    tableInputs = layoutManager->getTableInput(table.getName());
    tableOutputs = layoutManager->getTableOutput(table.getName());
    list<Rule> ruleList = layoutManager->getListRuleEnabled();
    list<ForbiddenPattern> patternList = layoutManager->getListFPEnabled();
    //Get te initial layout
    layout = layoutManager->getLayout()->getMatrix();
    initialGrid = layoutManager->getLayout()->getGrid();
    
    //Rotate rules
    for (list<Rule>::iterator i = ruleList.begin(); i != ruleList.end(); i++)
    {
        addRule((*i));
    }
    
    
    //Rotate patterns
    for (list<ForbiddenPattern>::iterator i = patternList.begin(); i != patternList.end(); i++)
    {
        addPattern((*i));
    }

    //Initialize simulation results data structures    
    row = 0;
    processedLayouts.resize((int)pow(2, tableInputs.size()));
    processedLayouts.clear();
    finalLayouts.resize((int)pow(2, tableInputs.size()));
    finalLayouts.clear();
    forbiddenLayouts.resize((int)pow(2, tableInputs.size()));
    cycles.resize((int)pow(2, tableInputs.size()));
    forbiddenLayouts.clear();
    //Initializes the simulation view and starts
    view = new SimulationView(controller->getNanoFrame(), wxID_ANY);
    simulation = new Simulation(view, this, layout, &rules, &patterns);
    view->setSimulation(simulation);
    startSimulation();
}


//TODO: mirar què fer si la rotació falla

void SimulationManager::addRule(Rule newRule)
{
    if (!findRule(newRule))
    {
        rules.push_back(newRule);
        
        //Rotate only if square and even size
        if ((newRule.getWidth() == newRule.getHeight()) && (newRule.getWidth() %2 != 0))
        {

            Grid tempInitial = newRule.getInitialGrid();
            Grid tempFinal = newRule.getFinalGrid();
    
            for (int i = 0; i < 5; i++)
            {
                Grid initialRotated(tempInitial.getWidth(), tempInitial.getHeight());
                Grid finalRotated(tempInitial.getWidth(), tempInitial.getHeight());
                Rule ruleRotated(newRule.getWidth(), newRule.getHeight());
                if (rotateGrid(tempInitial, &initialRotated) && rotateGrid(tempFinal, &finalRotated))
                {
                    ruleRotated.setInitialGrid(initialRotated);
                    ruleRotated.setFinalGrid(finalRotated);
                    if (!findRule(ruleRotated))
                    {
                        rules.push_back(ruleRotated);
                    }
                }
                else
                {   
                    cout << "Error in rotation " << i << endl;
                    break;
                }
                tempInitial = ruleRotated.getInitialGrid();
                tempFinal = ruleRotated.getFinalGrid();
            }
        }
    }
}



void SimulationManager::addPattern(ForbiddenPattern newPattern)
{
    if (!findPattern(newPattern))
    {
        patterns.push_back(newPattern);
        //Rotate only if square and even size
        if ((newPattern.getWidth() == newPattern.getHeight()) && (newPattern.getWidth() %2 != 0))
        {
            Grid temp = newPattern.getGrid();
    
            for (int i = 0; i < 5; i++)
            {
                Grid rotatedGrid(temp.getWidth(), temp.getHeight());
                ForbiddenPattern patternRotated(newPattern.getWidth(), newPattern.getHeight());
                if (rotateGrid(temp, &rotatedGrid))
                {
                    patternRotated.setGrid(rotatedGrid);
                    if (!findPattern(patternRotated))
                    {
                        patterns.push_back(patternRotated);
                    }
                }
                else
                {
                    break;
                }
                temp= patternRotated.getGrid();
            }
        }
    }
}



bool SimulationManager::findRule(Rule rule)
{
    for (list<Rule>::iterator i = rules.begin(); i != rules.end(); i++)
    {
        if (rule == (*i))
        {
            return true;
        }
    }
    return false;
}



bool SimulationManager::findPattern(ForbiddenPattern pattern)
{
    for (list<ForbiddenPattern>::iterator i = patterns.begin(); i != patterns.end(); i++)
    {
        if ((*i) == pattern)
        {
            return true;
        }
    }
    return false;
}



void SimulationManager::printRule(Rule rule)
{
    cout << "Initial" << endl;
    for (int i = 0; i < rule.getWidth(); i++)
    {
        for (int k = 0; k < i; k++)
        {
            cout << "  ";
        }
        for (int j = 0; j < rule.getHeight(); j++)
        {
            cout << rule.getInitialGrid()(i, j) << "  ";
        }
        cout << endl;
    }
    
    cout << endl;
    cout << "Final" << endl;
    for (int i = 0; i < rule.getWidth(); i++)
    {
        for (int k = 0; k < i; k++)
        {
            cout << "  ";
        }
        for (int j = 0; j < rule.getHeight(); j++)
        {
            cout << rule.getFinalGrid()(i, j) << "  ";
        }
        cout << endl;
    }
}



void SimulationManager::printPattern(Grid pattern)
{
    for (int i = 0; i < pattern.getWidth(); i++)
    {
        for (int k = 0; k < i; k++)
        {
            cout << " ";
        }
        for (int j = 0; j < pattern.getHeight(); j++)
        {
            cout << pattern(i, j) << " ";
        }
        cout << endl;
    }
}



bool SimulationManager::rotateGrid(Grid originalGrid, Grid *destGrid)
{
    int c;
    int center;
    int i, j;
    int ii, jj;
    int size = originalGrid.getWidth();

    
    center = size/2;

    for (i = 0; i < size; i++) 
    {
        for (j = 0; j < size; j++) 
        {
            (*destGrid)(i, j) = nDONTCARE;
        }
    }

    for (i = 0; i < size; i++) 
    {
        for (j = 0; j < size; j++) 
        {
            c = originalGrid(i, j);

            rotateHexCoordinate(center, i, j, &ii, &jj);
            
            if (0 <= ii && ii < size && 0 <= jj && jj < size) 
            {
                (*destGrid)(ii, jj) = c;
            }
            else if (c == nENABLED || c == nDISABLED)
            {
                cout << "Warning: cannot map a transformed site" << endl;
                return false;
            }
        }
    }
    return true;
}



void SimulationManager::rotateHexCoordinate(int center, int i, int j, int *ii, int *jj)
{
    int x, y;
    int xx, yy;

    x = i - center;
    y = j - center;

    xx = -y;
    yy = x + y;

    *ii = xx + center;
    *jj = yy + center;
}


//TODO: recorda, ha de ser tot vàlid:
//layout no null
//taula de veritat no nula
//inputs i outputs de la taula de veritat assignats
//això ho ha de controlar el check simulation i el 
//controlador principal habilitant i deshabilitant el botó
//que controla aquesta funció
//A MUST: abans de cridar aquesta funció s'ha de cridar
//prepareSimulation()

void SimulationManager::startSimulation()
{
    simulateRow();
}



bool SimulationManager::nextRow()
{
    return (row < pow(2, tableInputs.size()));
}


void SimulationManager::simulateRow()
{
    if (nextRow())
    {
        layout = layoutManager->getLayout()->getMatrix();
        vector<int> result(tableInputs.size(), nDISABLED);
        int j = tableInputs.size() -1 ;
        int l = row;
        while (l > 0)
        {
            if ((l % 2) == 1) //1 = True
            {
                result[j] = nENABLED;
            }  
            else
            {
                result[j] = nDISABLED;
            }
            l /= 2;  
            j--;
    }
    list<matrix> finalLayouts;
    for (unsigned int k = 0; k < tableInputs.size(); k++)
    {
        layout[tableInputs[k].x][tableInputs[k].y] = result[k];
    }
    for (unsigned int k = 0; k < tableOutputs.size(); k++)
    {
        layout[tableOutputs[k].x][tableOutputs[k].y] = nDISABLED;
    }
    simulation->resetSimulation(view, this, layout, &rules, &patterns);
    view->setBlankLine();
    view->setInfo(wxString::Format(_("Simulating row %d"), row));
    view->setBlankLine();
    }
    row++;
}


void SimulationManager::finishedRow()
{
    view->setInfo(wxString::Format(_("Gathering data from the row: %d"), row - 1));
    processedLayouts[row - 1] = simulation->getProcessedLayouts();
    finalLayouts[row - 1] = simulation->getStableLayouts();
    forbiddenLayouts[row - 1] = simulation->getForbiddenLayouts();
    cycles[row - 1] = simulation->getCycles();
}


void SimulationManager::results()
{
    if (!resultsView)
    {
        resultsView = new ResultsView(controller->getNanoFrame(), wxID_ANY, this);
        resultsView->Show(true);
    }
    rRow = 0;
    rInformation = 0;
    rPath = 0;
    updateRowList();
    updateInformationList();
    updatePathList();
    updateGrid();
    resultsView->updateInitialGrid(initialGrid, true);
    resultsView->setTable(table);
    resultsView->setInputs(tableInputs);
    resultsView->setOutputs(tableOutputs);
}



void SimulationManager::rowSelected(int row)
{
    rRow = row;
    rInformation = 0;
    rPath = 0;
    updateRowList();
    updateInformationList();
    updatePathList();
    updateGrid();
}



void SimulationManager::informationSelected(int information)
{
    rInformation = information;
    rPath = 0;
    updateInformationList();
    updatePathList();
    updateGrid();
}



void SimulationManager::pathSelected(int path)
{
    rPath = path;
    updatePathList();
    updateGrid();
}


void SimulationManager::updateRowList()
{
    //We must check here if the row verifies the
    //table or not
    bool verifies = true;
    wxArrayString s;
    for (int i = 0; i < (int)pow(2, tableInputs.size()); i++)
    {
        if (verifyRow(i))
        {
            s.Add(wxString::Format(_("Row %d: OK"), i + 1));
        }
        else
        {
            s.Add(wxString::Format(_("Row %d: KO"), i + 1));
            verifies = false;
        }
    }
    resultsView->updateRowList(s);
    resultsView->selectRow(rRow);
    resultsView->setResult(verifies);
}


void SimulationManager::updateInformationList()
{
    wxArrayString s;
    //First we must know if we must update
    //forbidden patterns or stable layouts
    if (forbiddenLayouts[rRow].size() > 0) //FPs
    {
        for (unsigned int i = 0; i < forbiddenLayouts[rRow].size(); i++)
        {
            s.Add(wxString::Format(_("Pattern %d"), i + 1));
        }
    }
    else if (finalLayouts[rRow].size() > 0)
    {
        for (unsigned int i = 0; i < finalLayouts[rRow].size(); i++)
        {
            s.Add(wxString::Format(_("Stable %d"), i + 1));
        }
    }
    else
    {
        for (unsigned int i = 0; i < cycles[rRow].size(); i++)
        {
            s.Add(wxString::Format(_("Cycle %d"), i + 1));
        }
    }
    resultsView->updateInformationList(s);
    resultsView->selectInformation(rInformation);
}


void SimulationManager::updatePathList()
{
    wxArrayString s;
    if (forbiddenLayouts[rRow].size() > 0) //FPs
    {
        list <simulationStep>::iterator it = forbiddenLayouts[rRow].begin();
        for (int i = 0; i < rInformation; i++)
        {
            it++;
        }
        simulationStep ss = *it;
        //We must know the path length of the FP
        for (unsigned int i =0; i < ss.path.size() + 1; i++)
        {
            s.Add(wxString::Format(_("Step %d"), i + 1));
        }
    }
    else if (finalLayouts[rRow].size() > 0)
    {
        list <simulationStep>::iterator it = finalLayouts[rRow].begin();
        for (int i = 0; i < rInformation; i++)
        {
            it++;
        }
        simulationStep ss = *it;
        //We must know the path length of the FP
        for (unsigned int i =0; i < ss.path.size() + 1; i++)
        {
            s.Add(wxString::Format(_("Step %d"), i + 1));
        }
    }
    else
    {
        list <simulationStep>::iterator it = cycles[rRow].begin();
        for (int i = 0; i < rInformation; i++)
        {
            it++;
        }
        simulationStep ss = *it;
        //We must know the path length of the Cycle
        for (unsigned int i =0; i < ss.path.size() + 1; i++)
        {
            s.Add(wxString::Format(_("Step %d"), i + 1));
        }
    }
    resultsView->updatePathList(s);
    resultsView->selectPath(rPath);
}


void SimulationManager::updateGrid()
{
    simulationStep ss;
    if (forbiddenLayouts[rRow].size() > 0) //FPs
    {
        list <simulationStep>::iterator it = forbiddenLayouts[rRow].begin();
        for (int i = 0; i < rInformation; i++)
        {
            it++;
        }
        ss = *it;
    }
    else if (finalLayouts[rRow].size() > 0) //Stable Layouts
    {
        list <simulationStep>::iterator it = finalLayouts[rRow].begin();
        for (int i = 0; i < rInformation; i++)
        {
            it++;
        }
        ss = *it;
    }
    
    else //Cycle --> to be done
    {
        list <simulationStep>::iterator it = cycles[rRow].begin();
        for (int i = 0; i < rInformation; i++)
        {
            it++;
        }
        ss = *it;
    }
    
    //Now we must know if the step is on the path or on the top
    if (rPath > (int)ss.path.size() - 1)
    {
        Grid g = ss.space;
        resultsView->updateGrid(g, false);
    }
    else
    {
        list<Grid>::iterator it = ss.path.begin();
        for (int i = 0; i < rPath; i++)
        {
            it++;
        }
        Grid g = (*it);
        resultsView->updateGrid(g, false);
    }
}



bool SimulationManager::verifyRow(int row)
{
    bool result = true;
    if (forbiddenLayouts[row].size() > 0)
    {
        result = false;
    }
    else if (finalLayouts[row].size() > 0)//Verify all the stable layouts
    {
        for (list<simulationStep>::iterator  i = finalLayouts[row].begin(); i != finalLayouts[row].end(); i++)
        {
            result = result && verifyGrid(row, (*i).space);
        }        
    }
    else //Bucles: TODO: comprovar també
    {
        result = false;
    }
    return result;
}



bool SimulationManager::verifyGrid(int row, Grid g)
{
    //Get the outputs values of the row
    vector<bool> result(tableInputs.size(), false);
    int j = tableInputs.size() -1 ;
    int k = row;
    while (k > 0)
    {
        if ((k % 2) == 1) //1 = True
        {
            result[j] = true;
        }  
        else
        {
            result[j] = false;
        }
        k /= 2;  
        j--;
    }
    vector<bool> outputs = table.getOutput(result);
    
    //Check the outputs are ok
    for (unsigned int i = 0; i < tableOutputs.size(); i++)
    {
        if (outputs[i]) //the position must be nENABLED
        {
            if (g(tableOutputs[i].x, tableOutputs[i].y) != nENABLED)
            {
                return false;
            }
        }
        else //the position must be nDISABLED
        {
            if (g(tableOutputs[i].x, tableOutputs[i].y) != nDISABLED)
            {
                return false;
            }
        }
    }
    return true;
}

---