VoltageIsland.cxx

Go to the documentation of this file.

#include "Annealer.h"
 
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdlib>

using namespace parquetfp;


IslandNodes::IslandNodes()
{
}

IslandNodes::IslandNodes(int node0, int node1, int group, int vdd)
{
  nodes.push_back(node0);
  nodes.push_back(node1);
  groupID = group;
  voltage = vdd;
}
/*
IslandNodes::~IslandNodes()
{

           cout << "destruct IslandNodes " << endl;
//         delete &voltage;
//         delete &groupID;
//         delete [] &nodes;
}
*/
void IslandNodes::setGroupID(int group)
{
        groupID = group;
}

SetOfVoltages::SetOfVoltages()
{
        numCurrentGroups = 0;
}

SetOfVoltages::~SetOfVoltages()
{
/*
          int i;
          delete &numCurrentGroups;                 //set to 0 on start and displays number of distinct voltage islands

          for(i=0;i<islandNodes.size();i++){
             delete &islandNodes[i];
          }

          cout << "destruct setofvoltages" << endl;

//        delete [] &islandNodes;
*/
}


void SetOfVoltages::addIslandNodes(int vdd, int node0, int node1)
{
  for(int i = 0; i < islandNodes.size();  i++) {
          if(islandNodes[i].voltage == vdd){
                 if((islandNodes[i].nodes[0] == node0) && (islandNodes[i].nodes[1] == node1))
                        return;
                 else if((islandNodes[i].nodes[1] == node0) && (islandNodes[i].nodes[0] == node1))
                        return;
          }
  }
  islandNodes.push_back(IslandNodes(node0,node1,numCurrentGroups,vdd));
  numCurrentGroups++;
}
  
void SetOfVoltages::createVoltageIslands()
{
        int i,j, currentID, currentVoltage, currentNode0, currentNode1;
        for(i = 0; i<islandNodes.size();i++){
                        currentID = islandNodes[i].groupID;
                        currentVoltage = islandNodes[i].voltage;
                        currentNode0 = islandNodes[i].nodes[0];
                        currentNode1 = islandNodes[i].nodes[1];
                        for(j=0;j<islandNodes.size();j++){
                                if( (islandNodes[j].voltage == currentVoltage) && (islandNodes[j].groupID != currentID) ){
                                        if( (islandNodes[j].nodes[0] == currentNode0) || (islandNodes[j].nodes[1] == currentNode0) ){
                                                islandNodes[j].setGroupID(currentID);
                                                if((islandNodes[j].nodes[0] == currentNode0) && (islandNodes[j].nodes.size() == 2)){
                                                        islandNodes[j].nodes.erase(islandNodes[j].nodes.begin() + 0, islandNodes[j].nodes.begin() + 1);
                                                }
                                                else if((islandNodes[j].nodes[1] == currentNode0) && (islandNodes[j].nodes.size() == 2)){
                                                        islandNodes[j].nodes.erase(islandNodes[j].nodes.begin() + 1, islandNodes[j].nodes.begin() + 2);
                                                }
                                                else islandNodes[j].nodes.clear();
                                                numCurrentGroups--;
                                        }
                                        else if( (islandNodes[j].nodes[0] == currentNode1) || (islandNodes[j].nodes[1] == currentNode1) ){
                                                islandNodes[j].setGroupID(currentID);
                                                if((islandNodes[j].nodes[0] == currentNode0) && (islandNodes[j].nodes.size() == 2)){
                                                        islandNodes[j].nodes.erase(islandNodes[j].nodes.begin() + 0, islandNodes[j].nodes.begin() + 1);
                                                }
                                                else if((islandNodes[j].nodes[1] == currentNode0) && (islandNodes[j].nodes.size() == 2)){
                                                        islandNodes[j].nodes.erase(islandNodes[j].nodes.begin() + 1, islandNodes[j].nodes.begin() + 2);
                                                }
                                                else islandNodes[j].nodes.clear();
                                                numCurrentGroups--;
                                        }
                                }
                        }
        }

 arrangeGroups();
}

void SetOfVoltages::printIslands()
{
        int i,j,k,currentID,printVoltage=1;
        for(i=0;i<numCurrentGroups;i++){
                currentID = i;
                for(j=0;j<islandNodes.size();j++){
                        if( (islandNodes[j].groupID == currentID) ){
                                if(printVoltage){
                                        printVoltage = 0;
                                        cout << "nodes in voltage island " << islandNodes[j].voltage << endl;
                                }
                                for(k=0;k<islandNodes[j].nodes.size();k++){
                                        cout << islandNodes[j].nodes[k] << " ";
                                }
                        }
                }
                cout << endl;
                printVoltage = 1;
        }
}

void SetOfVoltages::arrangeGroups()
{
        int i,j,k,idCounter=islandNodes.size(),currentID;
        for(i=0;i<islandNodes.size();i++){
                currentID = islandNodes[i].groupID;
                if(currentID < islandNodes.size()){
                        for(j=0;j<islandNodes.size();j++){
                                if(islandNodes[j].groupID == currentID)
                                        islandNodes[j].groupID = idCounter;
                        }
                        idCounter++;
                }
        }
        for(i=0;i<islandNodes.size();i++){
                islandNodes[i].groupID -= islandNodes.size();
        }
}

int SetOfVoltages::numIslandNodes()
{
  int i, j, count=0;
 
  for(i=0;i<islandNodes.size();i++){
    for(j=0;j<islandNodes[i].nodes.size();j++){
        count++;
    }
  }

 return count;
}

int SetOfVoltages::numIslandInGroup(int groupID)
{
  int j, k, currentID, count;

      currentID = groupID;
      count = 0;
      for(j=0;j<islandNodes.size();j++){
         if( (islandNodes[j].groupID == currentID) ){
           for(k=0;k<islandNodes[j].nodes.size();k++){
                count++;
               }
         }
      }
  return count;
}

int SetOfVoltages::voltageInGroup(int groupID)
{

   int j, k, currentID;

      currentID = groupID;
      for(j=0;j<islandNodes.size();j++){
         if( (islandNodes[j].groupID == currentID) ){
            return islandNodes[j].voltage;
         }
      }

}

int SetOfVoltages::maxIslandNodes()
{
  int i, j, k, currentID, count=0, prev_count=0;

  for(i=0;i<numCurrentGroups;i++){
      currentID = i;
      count = 0;
      for(j=0;j<islandNodes.size();j++){
         if( (islandNodes[j].groupID == currentID) ){
           for(k=0;k<islandNodes[j].nodes.size();k++){
                count++;
               }
         }
      }
     if(prev_count > count) count = prev_count;
     prev_count = count;
  }

 return count;
}

void SetOfVoltages::clearIslandNodes()
{

        for(int i=0;i<islandNodes.size();i++){
                islandNodes[i].nodes.clear();
        }
        islandNodes.erase(islandNodes.begin()+0,islandNodes.begin() + islandNodes.size());
    numCurrentGroups = 0;
}

---