/// <summary>
/// Deletes all runs associated with the specified journey.
/// </summary>
/// <param name="journey"></param>
public void Clean(Journey journey)
{
journey.RunUuids = new string[0];
string runsDir = string.Format("{0}\\{1}", this.directories[1], journey.Uuid);
if (Directory.Exists(runsDir))
{
new DirectoryInfo(runsDir).Delete(true);
}
}
public void TestSerialization()
{
Journey j = new Journey();
j.ShortName = "Jeff";
j.Description = "blah";
j.RunUuids = new[] { "a", "b", "c" };
var properties = j.Properties;
var provider = new PtvDataProvider();
ObjectCache.RegisterObject(provider);
properties.NetworkDataProviders = new[] { provider };
properties.PointDataProviders = new[] { new WalkingDataProvider() };
properties.PopulationSize = 100;
properties.DepartureTime = DateTime.Now;
properties.MutationRate = 0.1;
properties.CrossoverRate = 0.7;
// properties.Bidirectional = bidir;
// properties.RouteGenerator = new AlRouteGenerator(properties);
properties.SearchType = SearchType.Greedy_BiDir;
properties.RouteGenerator = new DFSRoutePlanner(properties);
properties.Mutator = new StandardMutator(properties);
properties.Breeder = new StandardBreeder(properties);
properties.FitnessFunction = new AlFitnessFunction(properties);
properties.Database = new MySqlDatabase("20110606fordistributionforrmit");
properties.SearchType = SearchType.Greedy_BiDir;
properties.Destination = new PtvNode(4, provider);
properties.Origin = new PtvNode(4, provider);
JourneyManager m = new JourneyManager();
m.Add(j);
m.Save();
m = new JourneyManager();
var j2 = m.GetJourney(j.Uuid);
Assert.That(j.Uuid == j2.Uuid);
}
public string NewJourney(string shortName, string description)
{
Journey newJourney = new Journey();
newJourney.ShortName = shortName;
newJourney.Description = description;
newJourney.Properties = new EvolutionaryProperties();
var jm = ObjectCache.GetObject<JourneyManager>();
jm.Add(newJourney);
return newJourney.Uuid;
}
public void CloneJourney(string journeyUuid, string newUuid)
{
if (journeyUuid == null)
{
throw new Exception(Strings.ERR_ANY_NULL);
}
var jm = ObjectCache.GetObject<JourneyManager>();
var j = jm.GetJourney(journeyUuid);
var newJ = new Journey(newUuid, j.Properties, newUuid, "");
jm.Add(newJ);
}
/// <summary>
/// The set property.
/// </summary>
/// <param name="journey">
/// The journey.
/// </param>
/// <param name="propVal">
/// The prop val.
/// </param>
/// <param name="testOnly">
/// The test only.
/// </param>
/// <returns>
/// </returns>
/// <exception cref="Exception">
/// </exception>
/// <exception cref="JsonException">
/// </exception>
/// <exception cref="JsonException">
/// </exception>
/// <exception cref="Exception">
/// </exception>
/// <exception cref="Exception">
/// </exception>
/// <exception cref="Exception">
/// </exception>
private ValidationError SetProperty(Journey journey, PropertyValue propVal, bool testOnly)
{
if (propVal.Name == null)
{
throw new Exception(
"Property value name is null. Cannot proceed with validation. Please check your JSON syntax.");
}
if (journey == null && !testOnly)
{
throw new JsonException("The journey UUID can only be null if the testOnly attribute is true.");
}
// var valErrors = new List<ValidationError>();
//var jp = ObjectCache.GetObject<JourneyManager>();
PropertyInfo[] propertyInfos = typeof(EvolutionaryProperties).GetProperties();
EvolutionaryProperties properties;
try
{
properties = journey.Properties;
}
catch (Exception)
{
throw new JsonException("The supplied journey UUID was incorrect.");
}
{
// foreach (var propVal in propVals)
var propertyInfo = propertyInfos.FirstOrDefault(s => s.Name == propVal.Name);
if (propertyInfo == null)
{
return new ValidationError { Target = propVal.Name, Message = Strings.ERR_PROP_NOT_FOUND };
// continue;
}
object castVal = null;
string errMess = string.Empty;
bool isList = false;
bool isArray = false;
if (propertyInfo.PropertyType.IsValueType)
{
try
{
if (propertyInfo.PropertyType.IsEnum)
{
castVal = Enum.Parse(propertyInfo.PropertyType, propVal.Value);
}
else
{
castVal = Convert.ChangeType(propVal.Value, propertyInfo.PropertyType);
}
}
catch (Exception e)
{
errMess = e.Message;
}
}
else
{
try
{
Type pType = propertyInfo.PropertyType;
switch (pType.Name)
{
case "INetworkNode":
if (propVal.Value == null)
{
throw new Exception("This field cannot be blank.");
}
PtvDataProvider provider = ObjectCache.GetObjects<PtvDataProvider>()[0];
PtvNode node = null;
try
{
node = (PtvNode)provider.GetNodeFromId(Convert.ToInt32(propVal.Value));
}
catch (KeyNotFoundException)
{
throw new Exception("There is no such node with the given ID or name.");
}
// provider.GetNodeFromName(propVal.Value);
if (node == null)
{
throw new Exception("No matching node for supplied name.");
}
castVal = node;
break;
case "FitnessParameter[]":
var objs = propVal.Value.Split(new[] { ',' });
var objectives = new FitnessParameter[objs.Length];
int i = 0;
foreach (var obj in objs)
{
FitnessParameter e;
if (!Enum.TryParse(obj, out e))
{
throw new Exception("Cannot parse string into enum.");
}
objectives[i++] = e;
}
castVal = objectives;
break;
default:
// var pType = new;
if (pType.IsGenericType)
{
if (pType.Name.Contains("List"))
{
pType = pType.GetGenericArguments()[0];
isList = true;
}
}
if (pType.IsArray)
{
pType = pType.GetElementType();
isArray = true;
}
try
{
var types = Assembly.GetAssembly(pType).GetTypes();
pType = types.Where(t => t.Name == propVal.Value).First();
}
catch (Exception)
{
throw new Exception("Cannot find type in assembly. (" + propVal.Value + ")");
}
// var pType = Assembly.GetAssembly (propertyInfo.PropertyType).GetType(propVal.Value,true,true);
var objects = ObjectCache.GetObjects(pType);
if (objects.Length == 0)
{
object newObj = null;
try
{
// newObj = pType.InvokeMember("",BindingFlags.CreateInstance,null,null,new[] {properties});
newObj = Activator.CreateInstance(pType, new[] { properties });
}
catch (Exception)
{
// newObj = pType.InvokeMember("",BindingFlags.CreateInstance,null,null,null);
newObj = Activator.CreateInstance(pType);
}
ObjectCache.RegisterObject(newObj);
castVal = newObj;
}
else
{
castVal = objects.First();
}
if (isArray)
{
var array = Array.CreateInstance(pType, 1);
array.SetValue(castVal, 0);
castVal = array;
}
break;
// throw new Exception("No handler for type: " + pType.Name);
}
}
catch (Exception e)
{
return new ValidationError
{
Target = propVal.Name,
Message = string.Format("{0}: {1}", Strings.ERR_UNSUPP_REFTYPE, e.Message)
};
}
}
if (castVal == null)
{
// ERR_INVALID_CAST
return new ValidationError
{
Target = propVal.Name,
Message = string.Format("{0}: {1}", Strings.ERR_INVALID_CAST, errMess)
};
// continue;
}
if (!testOnly)
{
if (isList)
{
IList a = (IList)propertyInfo.GetValue(properties, null);
a.Add(castVal);
}
else
{
propertyInfo.SetValue(properties, castVal, null);
}
}
}
return new ValidationError { Target = propVal.Name, Message = Strings.VALIDATION_SUCCESS };
}
public ValidationError SetProperty(Journey journey, PropertyValue propVal)
{
return this.SetProperty(journey, propVal, false);
}
/// <summary>
/// Called internally to process the journey optimisation queue.
/// </summary>
private void OptimisationLoop()
{
var detailedExportContext = JsonConvert.CreateExportContext();
var summaryExportContext = JsonConvert.CreateExportContext();
detailedExportContext.Register(new CritterExporter(CritterExporter.ExportType.Expanded));
summaryExportContext.Register(new CritterExporter(CritterExporter.ExportType.Summary));
{
// try
while (!this.cTokenSource.IsCancellationRequested)
{
string jUuid = string.Empty;
Run run = null;
//try
{
this.currentIteration = 0;
this.state = OptimiserState.Waiting;
if (this.bc.Count == 0 && this.exitThreadWhenQueueEmpty)
{
return;
}
this.Save();
jUuid = this.bc.Take(this.cTokenSource.Token);
this.state = OptimiserState.Optimising;
run = new Run();
var journey = this.journeyManager.GetJourney(jUuid);
this.currentJourney = journey;
run.JourneyUuid = journey.Uuid;
run.TimeStarted = DateTime.Now;
var planner = new MoeaJourneyPlanner(journey.Properties);
var results = new List<Result>(journey.Properties.MaxIterations);
this.maxIterations = journey.Properties.MaxIterations;
planner.Start();
for (int i = 0; i < journey.Properties.MaxIterations; i++)
{
this.currentIteration++;
planner.SolveStep();
results.Add((Result)planner.IterationResult.Clone());
while (this.paused)
{
Thread.Sleep(100);
}
// results.Add(planner.re);
if (this.cTokenSource.IsCancellationRequested)
{
break;
}
}
run.TimeFinished = DateTime.Now;
var maxTT = results.Max(r => r.Population.Max(p => p.Fitness.TotalTravelTime)).TotalSeconds;
var minTT = results.Min(r => r.Population.Min(p => p.Fitness.TotalTravelTime)).TotalSeconds;
var maxJT = results.Max(r => r.Population.Max(p => p.Fitness.TotalJourneyTime)).TotalSeconds;
var minJT = results.Min(r => r.Population.Min(p => p.Fitness.TotalJourneyTime)).TotalSeconds;
var maxCh = results.Max(r => r.Population.Max(p => p.Fitness.Changes));
var minCh = results.Min(r => r.Population.Min(p => p.Fitness.Changes));
foreach (var result in results)
{
foreach (var p in result.Population)
{
p.Fitness.NormalisedChanges = Math.Min(
1.0f, p.Fitness.Changes / (double)(maxCh - minCh));
p.Fitness.NormalisedJourneyTime = Math.Max(
1.0f, p.Fitness.TotalJourneyTime.TotalSeconds / (maxJT - minJT));
p.Fitness.NormalisedTravelTime = Math.Max(
1.0f, p.Fitness.TotalTravelTime.TotalSeconds / (maxTT - minTT));
}
}
if (!this.cTokenSource.IsCancellationRequested)
{
lock (journey.RunUuids)
{
// TODO: Make this more efficient/better coded
var newList = new List<string>(journey.RunUuids);
newList.Add(run.Uuid);
journey.RunUuids = newList.ToArray();
string dir = this.directories[1] + "/" + journey.Uuid + "/";
Directory.CreateDirectory(dir + run.Uuid);
using (var resultWriter = new StreamWriter(dir + run.Uuid + "/results.csv", false))
{
resultWriter.Write("Iteration,Hypervolume,Cardinality,");
foreach (var p in Enum.GetValues(typeof(FitnessParameter)))
{
resultWriter.Write("{0}, ", p);
}
resultWriter.WriteLine();
for (int i = 0; i < results.Count; i++)
{
using (
var writer = new StreamWriter(dir + run.Uuid + "/iteration." + i + ".json"))
{
results[i].Hypervolume = 0.0;
/*results[i].Population.CalculateHyperVolume(
journey.Properties.Objectives,
new double[journey.Properties.Objectives.Length]);*/
var grouped = from p in results[i].Population
group p by p.Route
into g
select g;
var candidates = new List<Critter>();
foreach (var g in grouped)
{
TimeSpan minTime = TimeSpan.MaxValue;
Critter minCrit = null;
foreach (var critter in g)
{
if (critter.Fitness.TotalJourneyTime < minTime)
{
minTime = critter.Fitness.TotalJourneyTime;
minCrit = critter;
}
}
candidates.Add(minCrit);
}
var groupedResult = (Result)results[i].Clone(true);
groupedResult.Population = new Population(candidates.OrderBy(c => c.Fitness.TotalJourneyTime));
detailedExportContext.Export(groupedResult, new JsonTextWriter(writer));
resultWriter.Write(
"{0}, {1}, {2}, ", i, results[i].Hypervolume, results[i].Cardinality);
foreach (var p in Enum.GetValues(typeof(FitnessParameter)))
{
resultWriter.Write(
"{0},",
results[i].Population.Average(c => c.Fitness[(FitnessParameter)p]));
}
resultWriter.WriteLine();
}
// For the last result entry, Save simplified file.
if (i != results.Count - 1)
{
continue;
}
using (var writer = new StreamWriter(dir + run.Uuid + "/simple.json"))
{
using (var jsonWriter = new JsonTextWriter(writer))
{
var grouped = from p in results[i].Population
group p by p.Route
into g
select g;
var candidates = new List<Critter>();
foreach (var g in grouped)
{
TimeSpan minTime = TimeSpan.MaxValue;
Critter minCrit = null;
foreach (var critter in g)
{
if (critter.Fitness.TotalJourneyTime < minTime)
{
minTime = critter.Fitness.TotalJourneyTime;
minCrit = critter;
}
}
candidates.Add(minCrit);
}
summaryExportContext.Export(candidates.OrderBy(c => c.Fitness.TotalJourneyTime), jsonWriter);
}
}
}
using (var writer = new StreamWriter(dir + run.Uuid + ".json"))
{
detailedExportContext.Export(run, new JsonTextWriter(writer));
}
results.Clear();
}
}
this.journeyManager.Save();
}
this.currentJourney = null;
this.currentIteration = 0;
this.maxIterations = 0;
}
/*
catch (Exception e)
{
StreamWriter logWriter = new StreamWriter("Log.txt");
logWriter.WriteLine(
"Exception: {0} jUUID: {1}, rUUID{2}, ST {3}\n\n",
e.Message,
jUuid,
(run ?? new Run { ErrorCode = -1, JourneyUuid = jUuid }).Uuid,
e.StackTrace);
logWriter.Close();
// throw;
}
*/
}
}
/*
catch (Exception e)
{
//this.thrownException = e;
throw;
}
finally
{
this.state = OptimiserState.Idle;
}
* */
}
public void Remove(Journey journey)
{
if (!bc.Contains(journey.Uuid))
return;
this.Pause();
var journeys = new List<string>(bc.Count);
while (bc.Count > 0)
{
journeys.Add(bc.Take());
}
foreach (String j in journeys)
{
if (j != journey.Uuid)
{
bc.Add(j);
}
}
this.Resume();
}
/// <summary>
/// Enqueues the journey in the optimisation queue.
/// </summary>
/// <param name="journey">
/// The journey you wish to enqueue.
/// </param>
/// <param name="runs">
/// The amount of times to add the journey to the queue.
/// </param>
public void EnqueueJourney(Journey journey, int runs)
{
EnqueueJourney(journey.Uuid, runs);
}
/// <summary>
/// Returns if this journey manager contains a journey with
/// a matching UUID to the specified journey.
/// </summary>
/// <param name="journey">The journey which is used for comparison.</param>
/// <returns>True if the UUIDs match, otherwise false.</returns>
public bool Contains(Journey journey)
{
return this.journeyMap.ContainsKey(journey.Uuid);
}
/// <summary>
/// Add the specified journey to the manager.
/// </summary>
/// <param name="journey">
/// The journey that is to be added to the manager.
/// </param>
public void Add(Journey journey)
{
this.journeyMap.Add(journey.Uuid, journey);
}
