public ScenarioPropertiesViewModel(Scenario scenario)
{
Scenario = scenario;
ScenarioName = Scenario.Name;
DurationString = ((TimeSpan)Scenario.Duration).ToString(TimeSpanFormatString);
Comments = Scenario.Comments;
ComputeSizes();
AddValidationRules(
new ValidationRule<ScenarioPropertiesViewModel>
{
PropertyName = "ScenarioName",
Description = "Must be unique within the selected location and cannot be null or empty",
IsRuleValid = (target, rule) => !string.IsNullOrEmpty(target.ScenarioName),
},
new ValidationRule<ScenarioPropertiesViewModel>
{
PropertyName = "PulseIntervalString",
Description = "Must be a valid, non-negative time span value in the format hh:mm where 00 <= hh <= 23; 00 <= mm <= 59",
IsRuleValid = (target, rule) =>
{
if (string.IsNullOrEmpty(target.DurationString)) return false;
TimeSpan timeSpan;
var isOK = TimeSpan.TryParseExact(target.DurationString, TimeSpanFormatString, null, out timeSpan);
return isOK && timeSpan.Ticks > 0;
},
});
}
public EnvironmentNode(Scenario scenario)
{
EnvironmentLayers.Add(new BitmapNode("Wind Speed", scenario.Wind));
EnvironmentLayers.Add(scenario.SoundSpeed);
EnvironmentLayers.Add(new BitmapNode("Bathymetry", scenario.Bathymetry));
EnvironmentLayers.Add(new BitmapNode("Sediment", scenario.Sediment));
scenario.PropertyChanged += (s, e) =>
{
var sender = (Scenario)s;
switch (e.PropertyName)
{
case "Wind":
EnvironmentLayers[0] = new BitmapNode("Wind", sender.Wind);
break;
case "SoundSpeed":
EnvironmentLayers[1] = sender.SoundSpeed;
break;
case "Bathymetry":
EnvironmentLayers[2] = new BitmapNode("Bathymetry", sender.Bathymetry);
break;
case "Sediment":
EnvironmentLayers[3] = new BitmapNode("Sediment", scenario.Sediment);
break;
}
};
}
public ScenarioNode(Scenario scenario)
{
Scenario = scenario;
Children.Add(scenario);
Children.Add(new AnalysisPointsNode(scenario));
Children.Add(new PerimetersNode(scenario));
Children.Add(new SpeciesNode(scenario));
Children.Add(new EnvironmentNode(scenario));
}
public static Simulation Create(Scenario scenario, string simulationDirectory)
{
Directory.CreateDirectory(simulationDirectory);
var result = new Simulation(scenario, simulationDirectory)
{
MovingAnimats = false,
AnimateSimulation = true,
TimeStepSize = (from p in scenario.Platforms
from s in p.Sources
from m in s.Modes
select (TimeSpan)m.PulseInterval).Max()
};
return result;
}
Simulation(Scenario scenario, string simulationDirectory)
{
_simulationDirectory = simulationDirectory;
//_database = SimulationContext.OpenOrCreate(Path.Combine(_simulationDirectory, "simulation.db"));
//_scenario = _database.ImportScenario(scenario);
Scenario = scenario;
_transmissionLossCache = new TransmissionLossCache("RadialCache", new NameValueCollection
{
{ "physicalMemoryLimitPercentage", "50" },
{ "pollingInterval", "00:05:00" }
});
foreach (var species in scenario.ScenarioSpecies)
GuidToColorMap.Add(species.Guid, species.LayerSettings.LineOrSymbolColor);
}
public AnalysisPointsNode(Scenario scenario)
{
_propertyObserver = new PropertyObserver<AnalysisPointsNode>(this)
.RegisterHandler(p => p.Scenario,
() =>
{
if (_collectionObserver != null) _collectionObserver.UnregisterHandler(AnalysisPointCollectionChanged);
else _collectionObserver = new CollectionObserver(Scenario.AnalysisPoints);
_collectionObserver.RegisterHandler(AnalysisPointCollectionChanged);
}
);
Scenario = scenario;
CheckForErrors();
}
internal void Log(Scenario scenario, string message) { LogBase(new LogEntry(scenario), message); }
public SpeciesNode(Scenario scenario) { Scenario = scenario; }
void AddPerimeter(Scenario scenario)
{
try
{
var locationGeoRect = (GeoRect)Scenario.Location.GeoRect;
var initialGeoRect = new GeoRect((locationGeoRect.North + locationGeoRect.Center.Latitude) / 2,
(locationGeoRect.South + locationGeoRect.Center.Latitude) / 2,
(locationGeoRect.East + locationGeoRect.Center.Longitude) / 2,
(locationGeoRect.West + locationGeoRect.Center.Longitude) / 2);
MapViewModel.EditablePolygonOverlayViewModel.GeoArray = new GeoArray(initialGeoRect.NorthWest, initialGeoRect.NorthEast, initialGeoRect.SouthEast, initialGeoRect.SouthWest, initialGeoRect.NorthWest);
MapViewModel.EditablePolygonOverlayViewModel.IsVisible = true;
MapViewModel.EditablePolygonOverlayViewModel.LocationBounds = locationGeoRect;
MapViewModel.EditablePolygonOverlayViewModel.AreCrossingSegmentsAllowed = false;
Globals.VisualizerService.ShowWindow("CreateOrEditPerimeterView",
new CreateOrEditPerimeterViewModel { EditablePolygonOverlayViewModel = MapViewModel.EditablePolygonOverlayViewModel, PerimeterName = "New perimeter", DialogTitle = "Create perimeter" },
true,
(sender, args) =>
{
MapViewModel.EditablePolygonOverlayViewModel.IsVisible = false;
var vm = (CreateOrEditPerimeterViewModel)args.State;
if (vm.IsCanceled) return;
Perimeter perimeter = MapViewModel.EditablePolygonOverlayViewModel.GeoArray;
perimeter.Name = vm.PerimeterName;
perimeter.Scenario = Scenario;
Scenario.Perimeters.Add(perimeter);
perimeter.UpdateMapLayers();
perimeter.LayerSettings.IsChecked = true;
});
OnPropertyChanged("IsSaveScenarioCommandEnabled");
}
catch (Exception e) { Globals.MessageBoxService.ShowError(e.Message); }
}
async void RepopulateAllSpecies(Scenario scenario)
{
foreach (var species in scenario.ScenarioSpecies)
await RepopulateSpeciesAsync(species);
}
Scenario CreateScenario(Location location, string scenarioName, string comments, TimePeriod timePeriod, TimeSpan duration, EnvironmentalDataSet wind, EnvironmentalDataSet soundSpeed, EnvironmentalDataSet bathymetry, EnvironmentalDataSet sediment)
{
var scenario = new Scenario
{
Wind = Globals.MasterDatabaseService.LoadOrCreateEnvironmentalDataSet(location, wind.Resolution, timePeriod, wind.SourcePlugin),
SoundSpeed = Globals.MasterDatabaseService.LoadOrCreateEnvironmentalDataSet(location, soundSpeed.Resolution, timePeriod, soundSpeed.SourcePlugin),
Bathymetry = Globals.MasterDatabaseService.LoadOrCreateEnvironmentalDataSet(location, bathymetry.Resolution, TimePeriod.Invalid, bathymetry.SourcePlugin),
Sediment = Globals.MasterDatabaseService.LoadOrCreateEnvironmentalDataSet(location, sediment.Resolution, TimePeriod.Invalid, sediment.SourcePlugin),
Name = scenarioName,
Location = location,
Comments = comments,
TimePeriod = timePeriod,
Duration = duration,
ShowAllPerimeters = true,
ShowAllAnalysisPoints = true,
ShowAllSpecies = false,
};
scenario.SoundSpeed.LayerSettings.LineOrSymbolSize = 5;
var existing = (from s in location.Scenarios
where s.Name == scenario.Name && s.Location == scenario.Location
select s).FirstOrDefault();
if (existing != null) throw new DuplicateNameException(String.Format("a Scenario named \"{0}\" already exists in the Location \"{1}\"; please select another name.", scenario.Name, scenario.Location.Name));
location.Scenarios.Add(scenario);
Globals.MasterDatabaseService.Context.Scenarios.Add(scenario);
return scenario;
}
public void CreateScenario(string locationName, string scenarioName, double north, double south, double east, double west)
{
Console.WriteLine("Creating database service...");
var database = new MasterDatabaseService { MasterDatabaseDirectory = _databaseDirectory };
Console.WriteLine("Loading plugins...");
var plugins = new PluginManagerService { PluginDirectory = PluginDirectory };
var cache = new EnvironmentalCacheService(plugins, database);
Console.WriteLine(string.Format("Looking for test location '{0}'...", locationName));
var location = database.FindLocation(locationName);
if (location != null)
{
Console.WriteLine(string.Format("Test location '{0}' already exists. Deleting the existing location.", locationName));
database.DeleteLocation(location);
}
Console.WriteLine(string.Format("Creating test location '{0}'...", locationName));
var geoRect = new GeoRect(north, south, east, west);
location = new Location
{
Name = locationName,
Comments = null,
GeoRect = geoRect
};
location.LayerSettings.IsChecked = true;
database.Add(location);
foreach (var month in NAVOConfiguration.AllMonths)
{
// SoundSpeed dataset for each month
Console.WriteLine(string.Format("Importing soundspeed for {0}", month));
cache.ImportDatasetTest(database.LoadOrCreateEnvironmentalDataSet(location, 15, month, plugins[PluginType.EnvironmentalDataSource, PluginSubtype.SoundSpeed].PluginIdentifier));
// Wind dataset for each month
Console.WriteLine(string.Format("Importing wind for {0}", month));
cache.ImportDatasetTest(database.LoadOrCreateEnvironmentalDataSet(location, 60, month, plugins[PluginType.EnvironmentalDataSource, PluginSubtype.Wind].PluginIdentifier));
}
// Sediment dataset
Console.WriteLine("Importing 5min sediment");
cache.ImportDatasetTest(database.LoadOrCreateEnvironmentalDataSet(location, 5f, TimePeriod.Invalid, plugins[PluginType.EnvironmentalDataSource, PluginSubtype.Sediment].PluginIdentifier));
Console.WriteLine("Importing 0.1min sediment");
cache.ImportDatasetTest(database.LoadOrCreateEnvironmentalDataSet(location, 0.1f, TimePeriod.Invalid, plugins[PluginType.EnvironmentalDataSource, PluginSubtype.Sediment].PluginIdentifier));
// Bathymetry dataset at 2min resolution
Console.WriteLine("Importing 2min bathymetry");
cache.ImportDatasetTest(database.LoadOrCreateEnvironmentalDataSet(location, 2f, TimePeriod.Invalid, plugins[PluginType.EnvironmentalDataSource, PluginSubtype.Bathymetry].PluginIdentifier));
// Bathymetry dataset at 1min resolution
Console.WriteLine("Importing 1min bathymetry");
cache.ImportDatasetTest(database.LoadOrCreateEnvironmentalDataSet(location, 1f, TimePeriod.Invalid, plugins[PluginType.EnvironmentalDataSource, PluginSubtype.Bathymetry].PluginIdentifier));
// Bathymetry dataset at 0.5min resolution
Console.WriteLine("Importing 0.5min bathymetry");
cache.ImportDatasetTest(database.LoadOrCreateEnvironmentalDataSet(location, 0.5f, TimePeriod.Invalid, plugins[PluginType.EnvironmentalDataSource, PluginSubtype.Bathymetry].PluginIdentifier));
Scenario scenario;
database.Add(scenario = new Scenario
{
Location = location,
Name = scenarioName,
Comments = string.Format("Some comments for {0}", scenarioName),
StartTime = new DbTimeSpan(new TimeSpan(0, 12, 0, 0)),
Duration = new DbTimeSpan(new TimeSpan(0, 1, 0, 0)),
TimePeriod = TimePeriod.April,
});
location.Scenarios.Add(scenario);
Platform platform;
database.Add(platform = new Platform
{
Description = "Platform description",
PlatformName = "PlatformName",
PlatformType = "PlatformType",
RepeatCount = 0,
Scenario = scenario,
Course = 45,
Depth = 0,
Geo = geoRect.Center,
Speed = 0,
IsRandom = false,
TrackType = TrackType.Stationary,
Perimeter = null,
});
Source source;
database.Add(source = new Source
{
Platform = platform,
SourceName = "SourceName",
SourceType = "SourceType",
});
database.Add(new Mode
{
ActiveTime = 500,
DepressionElevationAngle = 0,
Depth = 5,
HighFrequency = 3000,
HorizontalBeamWidth = 360,
LowFrequency = 3000,
MaxPropagationRadius = 25000,
ModeName = "ModeName",
ModeType = "ModeType",
//PSMModeGuid =
PulseInterval = new TimeSpan(0, 0, 0, 30),
PulseLength = new TimeSpan(0, 0, 0, 0, 500),
RelativeBeamAngle = 0,
Source = source,
SourceLevel = 200,
VerticalBeamWidth = 180,
});
database.SetEnvironmentalData(scenario,
(from data in location.EnvironmentalDataSets
where data.SourcePlugin.PluginSubtype == PluginSubtype.Wind && ((TimePeriod)scenario.TimePeriod == (TimePeriod)data.TimePeriod)
select data).FirstOrDefault());
database.SetEnvironmentalData(scenario,
(from data in location.EnvironmentalDataSets
where data.SourcePlugin.PluginSubtype == PluginSubtype.SoundSpeed && ((TimePeriod)scenario.TimePeriod == (TimePeriod)data.TimePeriod)
select data).FirstOrDefault());
database.SetEnvironmentalData(scenario,
(from data in location.EnvironmentalDataSets
where data.SourcePlugin.PluginSubtype == PluginSubtype.Sediment
orderby data.Resolution
select data).FirstOrDefault());
database.SetEnvironmentalData(scenario,
(from data in location.EnvironmentalDataSets
where data.SourcePlugin.PluginSubtype == PluginSubtype.Bathymetry
orderby data.Resolution
select data).FirstOrDefault());
database.SaveChanges();
}
public Scenario(Scenario scenario) : this()
{
Copy(scenario);
}
void AddPlatform(Scenario scenario)
{
if (scenario.LayerControl != null) ((LayerControl)scenario.LayerControl).Expand();
var platform = new Platform
{
Scenario = scenario,
Course = 0,
Depth = 0,
Description = null,
Geo = ((GeoRect)scenario.Location.GeoRect).Center,
PlatformName = "New Platform",
IsRandom = false,
Launches = false,
TrackType = TrackType.Stationary,
IsNew = true,
};
scenario.Platforms.Add(platform);
platform.UpdateMapLayers();
OnPropertyChanged("CanPlaceAnalysisPoint");
OnPropertyChanged("IsSaveScenarioCommandEnabled");
}
void SaveScenarioCopy(Scenario scenario)
{
var copy = new Scenario(scenario) { Name = "Copy of " + scenario.Name };
var copyNumber = 2;
while ((from s in scenario.Location.Scenarios
where s.Name == copy.Name
select s).FirstOrDefault() != null) copy.Name = "Copy " + copyNumber++ + " of " + scenario.Name;
scenario.Location.Scenarios.Add(copy);
Globals.MasterDatabaseService.Context.Scenarios.Add(copy);
}
void ViewScenarioProperties(Scenario scenario)
{
Globals.VisualizerService.ShowDialog("ScenarioPropertiesView", new ScenarioPropertiesViewModel(scenario));
}
void DeleteScenario(Scenario scenario)
{
if (IsSimulationRunning || IsTransmissionLossBusy)
{
Globals.MessageBoxService.ShowInformation("A scenario cannot be deleted while a simulation is running or transmission losses are being calculated. Please wait until these tasks finish.");
}
else
{
if (Globals.MessageBoxService.ShowYesNo(string.Format("Are you sure you want to delete the scenario \"{0}\"?", scenario.Name), MessageBoxImage.Warning) != MessageBoxResult.Yes) return;
scenario.Delete();
}
}
void LoadScenario(Scenario scenario) { Scenario = scenario; }
public PerimetersNode(Scenario scenario) { Scenario = scenario; }
static void AddPlatform(Scenario scenario, Platform platform)
{
scenario.Platforms.Add(platform);
platform.UpdateMapLayers();
}
void DeleteAllSpecies(Scenario scenario)
{
if (Globals.MessageBoxService.ShowYesNo("Are you sure you want to delete ALL the species from this scenario?", MessageBoxImage.Warning) != MessageBoxResult.Yes) return;
foreach (var species in scenario.ScenarioSpecies.ToList())
{
species.Delete();
OnPropertyChanged("IsRunSimulationCommandEnabled");
}
OnPropertyChanged("IsSaveScenarioCommandEnabled");
}
void Copy(Scenario scenario)
{
Name = scenario.Name;
Comments = scenario.Comments;
ShowAllAnalysisPoints = scenario.ShowAllAnalysisPoints;
ShowAllPerimeters = scenario.ShowAllPerimeters;
ShowAllSpecies = scenario.ShowAllSpecies;
StartTime = new TimeSpan(scenario.StartTime.Ticks);
Duration = new TimeSpan(scenario.Duration.Ticks);
TimePeriod = (TimePeriod)scenario.TimePeriod;
Location = scenario.Location;
Wind = scenario.Wind;
SoundSpeed = scenario.SoundSpeed;
Sediment = scenario.Sediment;
Bathymetry = scenario.Bathymetry;
// Here we map the old perimeter to the new perimeter so that the copied platform gets the proper perimeter
var perimeterMap = new Dictionary<Guid, Guid>();
foreach (var perimeter in scenario.Perimeters)
{
var newPerimeter = new Perimeter(perimeter) { Scenario = this };
perimeterMap.Add(perimeter.Guid, newPerimeter.Guid);
Perimeters.Add(newPerimeter);
}
var modeMap = new Dictionary<Guid, Guid>();
var allModes = new List<Mode>();
foreach (var platform in scenario.Platforms)
{
var newPlatform = new Platform(platform) { Scenario = this };
// Make sure the new perimeter gets the proper copied perimeter from the original scenario
if (platform.Perimeter != null) newPlatform.Perimeter = Perimeters.Find(p => p.Guid == perimeterMap[platform.Perimeter.Guid]);
Platforms.Add(newPlatform);
foreach (var source in platform.Sources)
{
var newSource = new Source(source) { Platform = newPlatform };
newPlatform.Sources.Add(newSource);
foreach (var mode in source.Modes)
{
var newMode = new Mode(mode) { Source = newSource };
modeMap.Add(mode.Guid, newMode.Guid);
newSource.Modes.Add(newMode);
allModes.Add(newMode);
}
}
}
foreach (var analysisPoint in scenario.AnalysisPoints)
{
var newAnalysisPoint = new AnalysisPoint(analysisPoint) { Scenario = this };
AnalysisPoints.Add(newAnalysisPoint);
foreach (var transmissionLoss in analysisPoint.TransmissionLosses)
{
var newTransmissionLoss = new TransmissionLoss { AnalysisPoint = newAnalysisPoint, LayerSettings = new LayerSettings(transmissionLoss.LayerSettings) };
foreach (var mode in transmissionLoss.Modes)
newTransmissionLoss.Modes.Add(allModes.Find(m => m.Guid == modeMap[mode.Guid]));
newAnalysisPoint.TransmissionLosses.Add(newTransmissionLoss);
foreach (var radial in transmissionLoss.Radials)
{
var newRadial = new Radial(radial) { TransmissionLoss = newTransmissionLoss };
newTransmissionLoss.Radials.Add(newRadial);
newRadial.CopyFiles(radial);
}
}
}
foreach (var species in scenario.ScenarioSpecies)
{
var newSpecies = new ScenarioSpecies(species) { Scenario = this };
ScenarioSpecies.Add(newSpecies);
newSpecies.CopyFiles(species);
}
}
async void AddSpecies(Scenario scenario)
{
var vm = new SpeciesPropertiesViewModel(new ScenarioSpecies
{
LatinName = "Generic odontocete",
PopulationDensity = 0.01f,
SpeciesDefinitionFilename = "Generic odontocete.spe"
})
{
WindowTitle = "Add new species"
};
var result = Globals.VisualizerService.ShowDialog("SpeciesPropertiesView", vm);
if ((!result.HasValue) || (!result.Value)) return;
var species = new ScenarioSpecies
{
Scenario = scenario,
LatinName = vm.LatinName,
PopulationDensity = vm.PopulationDensity,
SpeciesDefinitionFilename = vm.SpeciesDefinitionFilename,
};
try
{
scenario.ScenarioSpecies.Add(species);
species.LayerSettings.LineOrSymbolSize = 3;
var animats = await Animat.SeedAsync(species, scenario.Location.GeoRect, scenario.BathymetryData);
animats.Save(species.PopulationFilePath);
species.UpdateMapLayers();
}
catch (Exception e)
{
scenario.ScenarioSpecies.Remove(species);
Globals.MessageBoxService.ShowError(e.Message);
}
OnPropertyChanged("IsRunSimulationCommandEnabled");
OnPropertyChanged("IsSaveScenarioCommandEnabled");
}