private void UpdatePoiFrequencies()
{
using(var ctx = new CityContainer())
{
foreach (var poiFrequencyBox in PoiFrequencyBoxes)
{
var poiBoxName = poiFrequencyBox.Content.ToString();
var poiType = ctx.PoiTypes.Single(t => t.Code == poiBoxName);
double freqDouble;
if (!double.TryParse(poiFrequencyBox.Frequency, out freqDouble))
{
MessageBox.Show(string.Format("Invalid frequency value for POI '{0}", poiBoxName));
return;
}
poiType.Frequency = freqDouble;
}
ctx.SaveChanges();
}
}
public static void GeneratePOI(string cfgName, IEnumerable<PoiObject> poiObjects)
{
using (var ctx = new CityContainer())
{
var configuration = ctx.Configurations.Single(c => c.Name == cfgName);
var lastPoiType = string.Empty;
try
{
foreach (var poiObject in poiObjects)
{
var poi = new Poi
{
Configuration = configuration,
Vicinity = poiObject.Vicinity,
Name = poiObject.Name,
MapPoint = new MapPoint
{
Lat = poiObject.Latitude,
Lng = poiObject.Longitude
}
};
foreach (var type in poiObject.Types)
{
lastPoiType = type;
string poiType = lastPoiType;
poi.Type.Add(ctx.PoiTypes.Single(t => t.Code == poiType));
}
ctx.Pois.AddObject(poi);
}
ctx.SaveChanges();
}
catch (Exception e)
{
Logger.LogError("Unsupported POI type '{0}'. Please consider adding this "
+ "type to poi types configuration file.\n{1}", lastPoiType, e.Message);
}
}
}
public static bool SaveConfiguration(ConfigurationData data)
{
using (var ctx = new CityContainer())
{
var configurationExists = ctx.Configurations.Any(c => c.Name == data.ConfigurationName);
if (configurationExists) return false;
var poiTypes = ctx.PoiTypes.Where(t => data.PoiTypes.Contains(t.Code));
var newConfiguration = new Configuration
{
Name = data.ConfigurationName,
SelectionMethod = ctx.SelectionMethods.Single(m => m.Name == data.SimulationMethodName),
SimulationStartDate = data.SimulationStartDate,
SimulationEndDate = data.SimulationEndDate,
PersonDemandsPerDay = data.DemandsPerPersonPerDay,
CreditCardBalanceMin = data.CreditCardBalanceMin,
CreditCardBalanceMax = data.CreditCardBalanceMax,
CreditCardLimitMin = data.CreditCardLimitMin,
CreditCardLimitMax = data.CreditCardLimitMax,
TransactionValueMin = data.TransactionValueMin,
TransactionValueMax = data.TransactionValueMax
};
// Assign POI circle areas
foreach (var circleAreaObject in data.CircleAreas)
{
newConfiguration.CircleAreas.Add(new CircleArea
{
Configuration = newConfiguration,
Lat = circleAreaObject.Pushpin.Location.Latitude,
Lng = circleAreaObject.Pushpin.Location.Longitude,
Range = circleAreaObject.Range
});
}
// Assign POI types for configuration
foreach (var poiType in poiTypes)
newConfiguration.PoiTypes.Add(poiType);
// Assign Districts for configuration
foreach (var polygon in data.Polygons)
{
var district = new District
{
Configuration = newConfiguration,
Population = polygon.Population,
Name = polygon.DistrictName
};
foreach (var location in polygon.Locations)
{
district.MapPoints.Add(new MapPoint
{
Lat = location.Latitude,
Lng = location.Longitude
});
}
}
ctx.Configurations.AddObject(newConfiguration);
ctx.SaveChanges();
return true;
}
}
public static bool RemoveConfiguration(string cfgName)
{
try
{
using (var ctx = new CityContainer())
{
ctx.ContextOptions.LazyLoadingEnabled = false;
Logger.LogInfo("Removing configuration '{0}'", cfgName);
var configuration = ctx.Configurations
//.Include("Districts.Addresses.Residents.Demands.PoiTypes")
//.Include("Districts.Addresses.Residents.CreditCard")
.Include("Pois") //poi
.Include("CircleAreas")
.Include("Pois.Type")
.Include("PoiTypes")
.Include("Pois.MapPoint")
.Include("Districts.MapPoints")
.Include("Districts.Addresses.MapPoint")
.Single(s => s.Name == cfgName);
foreach (var poi in configuration.Pois)
{
poi.Type.Clear();
var mapPoint = poi.MapPoint;
ctx.Attach(mapPoint);
ctx.DeleteObject(mapPoint);
}
configuration.PoiTypes.Clear();
foreach (var mapPoint in
configuration.Districts.SelectMany(district => district.Addresses.Select(
address => address.MapPoint)))
{
ctx.Attach(mapPoint);
ctx.DeleteObject(mapPoint);
}
ctx.Configurations.DeleteObject(configuration);
ctx.SaveChanges();
}
return true;
}
catch (Exception)
{
return false;
}
}
public static void InsertStaticDataIfNeeded()
{
if(StaticDataExists())
{
Logger.LogInfo("Static data already exists. Skipping static data generation.");
return;
}
var poiList = File.ReadLines(Properties.Settings.Default.poi_file);
var currencies = File.ReadLines(Properties.Settings.Default.currencies_file);
var banks = File.ReadLines(Properties.Settings.Default.banks_file);
var simulationMethods = SymulationType.List();
using(var ctx = new CityContainer())
{
foreach (var poi in poiList)
ctx.PoiTypes.AddObject(new PoiType {Code = poi});
foreach(var currency in currencies)
ctx.Currencies.AddObject(new Currency{Code = currency});
foreach (var bank in banks)
ctx.Banks.AddObject(new Bank {Name = bank});
foreach (var simulationMethod in simulationMethods)
ctx.SelectionMethods.AddObject(new SelectionMethod {Name = simulationMethod});
ctx.SaveChanges();
}
InsertPeopleTemplates();
}
public static void InsertPeopleTemplates()
{
var maleEntries = File.ReadLines(Properties.Settings.Default.male_file);
var femaleEntries = File.ReadLines(Properties.Settings.Default.female_file);
using(var ctx = new CityContainer())
{
// Add male templates
foreach (var split in maleEntries.Select(male => male.Split(';')))
ctx.PersonTemplates.AddObject(
new PersonTemplate { FirstName = split[0], LastName = split[1], IsMale = true });
// Add female templates
foreach (var split in femaleEntries.Select(female => female.Split(';')))
ctx.PersonTemplates.AddObject(
new PersonTemplate { FirstName = split[0], LastName = split[1], IsMale = false });
ctx.SaveChanges();
}
}
public static void GeneratePOI(string cfgName, string poiXml)
{
using (var ctx = new CityContainer())
{
var configuration = ctx.Configurations.Single(c => c.Name == cfgName);
var document = XDocument.Load(poiXml);
var results = from c in document.Descendants("result")
select new {
// ReSharper disable PossibleNullReferenceException
Vicinity = c.Element("vicinity").Value,
Name = c.Element("name").Value,
Lat = c.Element("geometry").Element("location").Element("lat").Value,
Lng = c.Element("geometry").Element("location").Element("lng").Value,
Types = c.Elements("type").Select(v => v.Value)
// ReSharper restore PossibleNullReferenceException
};
foreach (var result in results)
{
var poi = new Poi
{
Configuration = configuration,
Vicinity = result.Vicinity,
Name = result.Name,
MapPoint = new MapPoint
{
Lat = CommonUtilities.ParseDouble(result.Lat),
Lng = CommonUtilities.ParseDouble(result.Lng)
}
};
var lastPoiType = string.Empty;
try
{
foreach (var type in result.Types)
{
lastPoiType = type;
var poiType = lastPoiType;
poi.Type.Add(ctx.PoiTypes.Single(t => t.Code == poiType));
}
ctx.Pois.AddObject(poi);
}
catch (Exception e)
{
Logger.LogError("Unsupported POI type '{0}'. Please consider adding this type to poi types configuration file.\n{2}", lastPoiType, e.Message);
}
}
ctx.SaveChanges();
}
File.Delete(poiXml);
}
private void GenerateTransactions(string cfgName, ProgressWindow progress)
{
using(var ctx = new CityContainer())
{
var selectionMethodName = ctx.Configurations.Single(c => c.Name == cfgName).SelectionMethod.Name;
Logger.LogInfo("Using POI selection method: {0}", selectionMethodName);
var demandsInConfiguration = ctx.Demands.Where(d => d.Person.Address.District.Configuration.Name == cfgName);
var totalTransactions = demandsInConfiguration.Count();
foreach (var demand in demandsInConfiguration)
{
if (progress.Worker.CancellationPending)
{
progress.Args.Cancel = true;
_simulationCancelled = true;
return;
}
var demandType = demand.PoiType.Code;
var matchingPois = ctx.Pois.Where(p => p.Type.Select(k => k.Code).Contains(demandType));
var selectedPoi = SelectPoi(matchingPois, demand.Person.Address.MapPoint, selectionMethodName);
if (selectedPoi == null) continue;
var transactionValue = StatisticalData.TransactionValue;
var creditCard = demand.Person.CreditCard;
var balanceAfterTransaction = creditCard.Balance - transactionValue;
if (balanceAfterTransaction < creditCard.Limit) continue;
creditCard.Balance -= transactionValue;
creditCard.Balance = Math.Round(creditCard.Balance, 2);
var transactionDateTime = demand.DateTime
.AddHours(Random.Next(0,24))
.AddMinutes(Random.Next(0,60))
.AddSeconds(Random.Next(0,60));
var transaction = new Transaction
{
Demand = demand,
CreditCard = creditCard,
Poi = selectedPoi,
Value = transactionValue,
DateTime = transactionDateTime
};
ctx.Transactions.AddObject(transaction);
demand.Fulfilled = true;
++progress.Current;
progress.InvokeUpdate(totalTransactions, GeneratingTransactionsMsg);
}
progress.InvokeUpdate(totalTransactions, GeneratingTransactionsMsg + PersistingMsg);
ctx.SaveChanges();
}
}
private static void GeneratePeopleData(string cfgName, ProgressWindow progress)
{
using (var ctx = new CityContainer())
{
var cfgDistricts = ctx.Districts.Where(d => d.Configuration.Name == cfgName);
var totalAddresses = cfgDistricts.Select(d => d.Population).Sum();
foreach (var district in cfgDistricts)
{
Logger.LogInfo("generating people for district.");
var locations = GeoUtilities.MapPointsToLocations(district.MapPoints);
for (var i = 0; i < district.Population; i++)
{
if (progress.Worker.CancellationPending)
{
progress.Args.Cancel = true;
_simulationCancelled = true;
return;
}
Logger.LogInfo("generating person {0} / {1}", i + 1, district.Population);
var bankId = Random.Next(1, ctx.Banks.Count() + 1);
var currencyId = Random.Next(1, ctx.Currencies.Count() + 1);
var ccNumber = StatisticalData.CreditCardNumber;
var personCreditCard = new CreditCard
{
Balance = StatisticalData.CreditCardBalance,
Limit = StatisticalData.CreditCardLimit,
Bank = ctx.Banks.Single(b => b.Id == bankId),
Currency = ctx.Currencies.Single(c => c.Id == currencyId),
Number = ccNumber
};
var templateId = Random.Next(1, ctx.PersonTemplates.Count() + 1);
var person = new Person
{
Template = ctx.PersonTemplates.Single(t => t.Id == templateId),
CreditCard = personCreditCard
};
var addressGeo = GeoUtilities.RandomLocationWithinPolygon(locations);
var address = new Address
{
District = district,
MapPoint = new MapPoint
{
Lat = addressGeo.Latitude,
Lng = addressGeo.Longitude
}
};
address.Residents.Add(person);
ctx.Addresses.AddObject(address);
++progress.Current;
progress.InvokeUpdate(totalAddresses, GeneratingPeopleMsg);
}
}
progress.InvokeUpdate(totalAddresses, GeneratingPeopleMsg + PersistingMsg);
ctx.SaveChanges();
}
}
private static void GenerateDemands(string cfgName, ProgressWindow progress)
{
try
{
Logger.LogInfo("Adding demand pool...");
using (var ctx = new CityContainer())
{
var cfg = ctx.Configurations.Single(c => c.Name == cfgName);
var peopleInConfiguration =
ctx.People.Where(p => p.Address.District.Configuration.Name == cfgName).OrderBy(o => o.Id);
//poi types from poi list (not configuration) because some poi types might be missing (not found)
var poiTypeCollections = ctx.Pois.Select(p => p.Type);
var poiSet = new HashSet<PoiType>();
foreach (var poiTypeCollection in poiTypeCollections)
foreach (var poiType in poiTypeCollection)
poiSet.Add(poiType);
var statisticalData = new StatisticalData();
var totalDays = cfg.SimulationEndDate.Subtract(cfg.SimulationStartDate).Days + 1;
var totalPeople = peopleInConfiguration.Count();
var demandsPerDay = (int) (totalPeople * cfg.PersonDemandsPerDay);
var totalDemands = totalDays * demandsPerDay;
for (var dayNr = 0; dayNr < totalDays; dayNr++)
{
var currentDate = cfg.SimulationStartDate.AddDays(dayNr);
for (var demandNr = 0; demandNr < demandsPerDay; demandNr++)
{
if (progress.Worker.CancellationPending)
{
progress.Args.Cancel = true;
_simulationCancelled = true;
return;
}
var randomPersonIndex = Random.Next(0, totalPeople);
var person = peopleInConfiguration.Skip(randomPersonIndex).First();
var demandDateTime = currentDate
.AddHours(Random.Next(0, 24))
.AddMinutes(Random.Next(0, 60))
.AddSeconds(Random.Next(0, 60));
var demand = new Demand
{
Person = person,
DateTime = demandDateTime,
PoiType = statisticalData.TakePoiByDistribution(poiSet)
};
ctx.Demands.AddObject(demand);
++progress.Current;
progress.InvokeUpdate(totalDemands, GeneratingDemandsMsg);
}
}
progress.InvokeUpdate(totalDemands, GeneratingDemandsMsg + PersistingMsg);
ctx.SaveChanges(); // Persist after each day.
}
Logger.LogInfo("Demands pool added.");
}
catch(Exception e1)
{
Logger.LogInfo(e1.Message);
}
}