private void finalSolutionHelper(SolutionsMessage solutionsMessage)
{
//File.Create("Solution.txt");
FileStream fs1 = new FileStream("Solution.txt", FileMode.OpenOrCreate, FileAccess.Write);
StreamWriter writer = new StreamWriter(fs1);
byte[] data = solutionsMessage.Solutions[0].Data;
BinaryFormatter formatter = new BinaryFormatter();
Result finalResults = (Result)formatter.Deserialize(new MemoryStream(data));
SmartConsole.PrintHeader("TASK ID: " + solutionsMessage.Id + " RESULTS");
writer.WriteLine("TASK ID: " + solutionsMessage.Id + " RESULTS");
int[] finalRoute = finalResults.route;
float finalDistance = finalResults.length;
List <int> nextDays = finalResults.nextDay;
SmartConsole.PrintLine("Distance: " + finalDistance, SmartConsole.DebugLevel.Advanced);
writer.WriteLine("Distance: " + finalDistance);
int vehicleIndex = 0;
string msg = "";
for (int i = 0; i < finalRoute.Length; i++)
{
if (finalRoute[i] == -1)
{
msg += "\n";
}
else
{
msg += finalRoute[i] + ", ";
}
}
SmartConsole.PrintLine("Path: \n" + msg, SmartConsole.DebugLevel.Advanced);
writer.Write("Path: \n" + msg);
string nextDayStr = "";
for (int l = 0; l < nextDays.Count; l++)
{
nextDayStr += nextDays[l] + ", ";
}
if (!nextDayStr.Equals(""))
{
SmartConsole.PrintLine("Next Day: \n" + nextDayStr, SmartConsole.DebugLevel.Advanced);
writer.Write("\nNext Day: \n" + nextDayStr);
}
writer.Close();
fs1.Close();
Program.doWork = false;
}
/*******************************************************************/
/************************* PUBLIC METHODS **************************/
/*******************************************************************/
/// <summary>
///
/// </summary>
/// <param name="runBoostData">
/// Whether the data should be boosted:
/// We increate amount of observations in order to
/// have a more reliable data set.
/// </param>
public void Compute(bool runBoostData = false)
{
SmartConsole.PrintHeader("PREDICTION STRENGTH");
if (runBoostData)
{
SmartConsole.PrintLine("Running Data Boost ... ", SmartConsole.DebugLevel.Advanced);
boostData();
}
psLogic();
SmartConsole.PrintLine("The best k = " + best_k, SmartConsole.DebugLevel.Advanced);
}
/*******************************************************************/
/************************* PUBLIC METHODS **************************/
/*******************************************************************/
/// <summary>
/// Computes the k-means
/// </summary>
/// <returns></returns>
public bool Compute()
{
SmartConsole.PrintHeader("K-MEANS");
if (data.Count < k)
{
SmartConsole.PrintLine("Cluster count is too big for data set, returning false", SmartConsole.DebugLevel.Advanced);
return(false);
}
SmartConsole.PrintLine("The configurations:", SmartConsole.DebugLevel.Advanced);
SmartConsole.PrintLine("k = " + k, SmartConsole.DebugLevel.Advanced);
SmartConsole.PrintLine("max_iter = " + max_iter, SmartConsole.DebugLevel.Advanced);
SmartConsole.PrintLine("distance_tolerance = " + distance_tolerance, SmartConsole.DebugLevel.Advanced);
kmeansLogic();
SmartConsole.PrintLine("K-means finished after " + current_iter + " iterations", SmartConsole.DebugLevel.Advanced);
return(true);
}
/*******************************************************************/
/************************ PRIVATE METHODS **************************/
/*******************************************************************/
/*******************************************************************/
/************************* PUBLIC METHODS **************************/
/*******************************************************************/
public void InitiatePrimary(IPAddress address, int port)
{
SmartConsole.PrintHeader("Starting primary server");
SmartConsole.PrintLine("Address: " + address.ToString() + ":" + port, SmartConsole.DebugLevel.Advanced);
// Create overall system tracker
SystemTracker systemTracker = new SystemTracker();
// Create list of all clients
ClientTracker clientTracker = new ClientTracker();
// Start measuring timeout
clientTracker.StartTimeout();
// Task Tracker
TaskTracker taskTracker = new TaskTracker();
// Start network connection
NetworkServer server = new NetworkServer(address, port);
server.Open();
// Create messageHandler
MessageHandler messageHandler = new MessageHandler(systemTracker, clientTracker, taskTracker, server);
// Start message queue
MessageQueue messageQueue = new MessageQueue(server);
messageQueue.Start();
// Start Message processor
CommunicationServer.MessageCommunication.MessageProcessor messageProcessor = new CommunicationServer.MessageCommunication.MessageProcessor(messageQueue, messageHandler);
messageProcessor.Start();
Thread.Sleep(100);
// Start console manager
ConsoleManager consoleManager = new ConsoleManager(server);
consoleManager.Start();
}
/*******************************************************************/
/************************ PRIVATE METHODS **************************/
/*******************************************************************/
/// <summary>
/// Runs the algorithm for configuration given by constructor
/// </summary>
private void psLogic()
{
SmartConsole.PrintHeader("PREDICTION STRENGTH");
// 1) get learning and testing set
//
splitTrainingData();
// 2) compute ps for each k and find the best_k
best_k = 1;
double max_strength = 0;
strengths = new double[max_k];
for (int k = start_k; k <= max_k; k++)
{
double strength = psValue(learningSet, testingSet, k);
strengths[k - start_k] = strength;
if (k == start_k)
{
max_strength = strength;
best_k = k;
}
else if (STRENGTH_TOL < strength)
{
max_strength = strength;
best_k = k;
}
SmartConsole.PrintLine("ps(" + k + ") = " + strength, SmartConsole.DebugLevel.Advanced);
}
SmartConsole.PrintHeader("PREDICTION STRENGTH FINISHED: ");
for (int k = start_k; k <= max_k; k++)
{
SmartConsole.PrintLine("ps(" + k + ") = " + strengths[k - start_k], SmartConsole.DebugLevel.Advanced);
}
}
public void InitiateBackup(IPAddress myAddress, int myPort, IPAddress masterAddress, int masterPort)
{
SmartConsole.PrintHeader("Starting backup server");
SmartConsole.PrintLine("Address: " + myAddress.ToString() + ":" + myPort, SmartConsole.DebugLevel.Advanced);
// Create overall system tracker
SystemTracker systemTracker = new SystemTracker();
// Create list of all clients
ClientTracker clientTracker = new ClientTracker();
// Task Tracker
TaskTracker taskTracker = new TaskTracker();
// Start network connection
NetworkServer server = new NetworkServer(myAddress, myPort);
// Create messageHandler
MessageHandler messageHandler = new MessageHandler(systemTracker, clientTracker, taskTracker, server);
// Start message queue
MessageQueue messageQueue = new MessageQueue(server);
// Start Message processor
CommunicationServer.MessageCommunication.MessageProcessor messageProcessor = new CommunicationServer.MessageCommunication.MessageProcessor(messageQueue, messageHandler);
// blockade to block untill server is switched to primary mode
Object backupBlockade = new Object();
server.Open();
messageQueue.Start();
messageProcessor.Start();
/********************* REGISTER AS NORMAL CLIENT *********************/
RegisterType type = RegisterType.CommunicationServer;
NetworkNode node = new NetworkNode(type);
systemTracker.Node = node;
NetworkClient client = new NetworkClient(masterAddress, masterPort);
client.Connect();
SmartConsole.PrintLine("Sending Register message...", SmartConsole.DebugLevel.Advanced);
CommunicationServer.MessageCommunication.KeepAliveTimer keepAliveTimer = new
CommunicationServer.MessageCommunication.KeepAliveTimer(messageHandler,
client,
server,
systemTracker,
node,
clientTracker,
backupBlockade);
keepAliveTimer.Communicate(node.ToRegisterMessage());
/********************* START COMMUNICATING WITH PRIMARY SERVER *********************/
SmartConsole.PrintLine("Backup Server starting work", SmartConsole.DebugLevel.Advanced);
keepAliveTimer.Start();
// This will hold untill server is switched to primary mode
lock (backupBlockade)
{
Monitor.Wait(backupBlockade);
}
/********************* SWITCH TO PRIMARY SERVER *********************/
SmartConsole.PrintHeader("SWITCHING TO PRIMARY");
Server.primaryMode = true;
client.Disconnect();
clientTracker.RefreshTimeout();
// Start measuring timeout
clientTracker.StartTimeout();
// Start console manager
ConsoleManager consoleManager = new ConsoleManager(server);
consoleManager.Start();
}
public override byte[] MergeSolution(byte[][] solutions)
{
int start_k = 1;
int max_k = 5;
BinaryFormatter formatter = new BinaryFormatter();
int size = solutions.Length;
Result[] partialSolutions = new Result[size];
List <List <Result> > partialSolutionsByID = new List <List <Result> >();
for (int i = 0; i < max_k; i++)
{
partialSolutionsByID.Add(new List <Result>());
}
for (int i = 0; i < size; i++)
{
Result result = (Result)formatter.Deserialize(new MemoryStream(solutions[i]));
partialSolutionsByID[result.ID - 1].Add(result);
}
List <int[]> finalRoutes = new List <int[]>();
List <int> finalRoutesSize = new List <int>();
List <float> finalDistances = new List <float>();
List <List <int> > nextDays = new List <List <int> >();
for (int i = 0; i < partialSolutionsByID.Count; i++)
{
finalRoutesSize.Add(0);
finalDistances.Add(0);
}
for (int i = 0; i < partialSolutionsByID.Count; i++)
{
for (int j = 0; j < partialSolutionsByID[i].Count; j++)
{
Result result = partialSolutionsByID[i][j];
finalDistances[i] += result.length;
finalRoutesSize[i] += result.route.Length;
}
finalRoutesSize[i] += partialSolutionsByID[i].Count - 1;
}
for (int i = 0; i < partialSolutionsByID.Count; i++)
{
int[] route = new int[finalRoutesSize[i]];
finalRoutes.Add(route);
}
for (int i = 0; i < partialSolutionsByID.Count; i++)
{
nextDays.Add(new List <int>());
int finalRouteIndex = 0;
for (int j = 0; j < partialSolutionsByID[i].Count; j++)
{
Result result = partialSolutionsByID[i][j];
nextDays[i].AddRange(result.nextDay);
int[] route = result.route;
for (int l = 0; l < route.Length; l++)
{
finalRoutes[i][finalRouteIndex++] = route[l];
}
if (j != partialSolutionsByID[i].Count - 1)
{
finalRoutes[i][finalRouteIndex++] = -1;
}
}
}
// print
for (int i = 0; i < finalRoutes.Count; i++)
{
int[] finalRoute = finalRoutes[i];
float finalDistance = finalDistances[i];
int k = i + 1;
SmartConsole.PrintHeader(" RESULT FOR K = " + k);
SmartConsole.PrintLine("Distance: " + finalDistance, SmartConsole.DebugLevel.Advanced);
string msg = "";
for (int l = 0; l < finalRoute.Length; l++)
{
if (finalRoute[l] == -1)
{
msg += "\n";
}
else
{
msg += finalRoute[l] + ", ";
}
}
SmartConsole.PrintLine("Path: \n" + msg, SmartConsole.DebugLevel.Advanced);
string nextDayStr = "";
for (int l = 0; l < nextDays[i].Count; l++)
{
nextDayStr += nextDays[i][l] + ", ";
}
if (!nextDayStr.Equals(""))
{
SmartConsole.PrintLine("Next Day: \n" + nextDayStr, SmartConsole.DebugLevel.Advanced);
}
}
// Find min
int minIndex = 0;
float min = finalDistances[minIndex];
for (int i = 0; i < finalDistances.Count; i++)
{
float dinstance = finalDistances[i];
if (min > dinstance)
{
min = dinstance;
minIndex = i;
}
}
Result finalSolution = new Result(finalRoutes[minIndex], finalDistances[minIndex], nextDays[minIndex]);
byte[] data = DataSerialization.ObjectToByteArray(finalSolution);
return(data);
}