static void SaveModel(NetworkModel model, OxyPlot.Series.LineSeries series = null)
{
Console.WriteLine("\nSaving model...");
if (series != null)
{
try
{
var graphPoints = new List <Vector <double> >();
foreach (var point in series.Points)
{
graphPoints.Add(Vector <double> .Build.Dense(new double[] { point.Y }));
}
DelimitedWriter.Write(model.Path("graph"), Matrix <double> .Build.DenseOfRowVectors(graphPoints));
Console.WriteLine("Saved graph data");
}
catch
{
Console.WriteLine("Unable to save graph data");
}
}
model.Save();
Console.WriteLine("Model has been saved.");
}
public NetworkGenerator <T> Startup(NetworkModel model, T fnData, T snData)
{
m_storedNetwork = new Network <T>();
m_currentModel = model;
StartModel(fnData, snData);
return(this);
}
public GdaService(StatelessServiceContext context)
: base(context)
{
this.logger = CloudLoggerFactory.GetLogger(ServiceEventSource.Current, context);
this.baseLogString = $"{this.GetType()} [{this.GetHashCode()}] =>{Environment.NewLine}";
Logger.LogDebug($"{baseLogString} Ctor => Logger initialized");
try
{
//LOGIC
_ = Config.GetInstance(this.Context);
string debugMessage = $"{baseLogString} Ctor => Configuration initialized.";
Logger.LogDebug(debugMessage);
//LOGIC
this.networkModel = new NetworkModel();
string infoMessage = $"{baseLogString} Ctor => NetworkModel created.";
Logger.LogInformation(infoMessage);
//LOGIC
this.genericDataAccess = new GenericDataAccess(networkModel);
this.nmsTransactionActor = new NmsTransactionActor(networkModel);
infoMessage = $"{baseLogString} Ctor => Contract providers initialized.";
Logger.LogInformation(infoMessage);
}
catch (Exception e)
{
string errMessage = $"{baseLogString} Ctor => Exception caught: {e.Message}.";
Logger.LogError(errMessage, e);
}
}
public static void Main(string[] args)
{
var netconfig = args.GetArgValue <string>("netconfig");
var startNodeIndex = args.GetArgValue <int>("startnode");
var targetNodeIndex = args.GetArgValue <int>("targetnode");
var log = args.ContainsArg("log");
string logFile = null;
if (log)
{
logFile = Path.Combine(Path.GetDirectoryName(netconfig), "logs",
Path.GetFileNameWithoutExtension(netconfig) + ".log");
}
try
{
var networkModel = new NetworkModel(netconfig, startNodeIndex, targetNodeIndex);
Output(networkModel, logFile);
foreach (var path in networkModel.Paths)
{
var t = CreateRange(0, 2, 0.1);
var y = networkModel.ComputeGt(path, 0, t);
PlotChart(y);
}
}
catch (Exception ex)
{
ConsoleColorWrite("ERROR:", ConsoleColor.Red);
Console.WriteLine(ex);
}
Console.ReadLine();
}
public IHttpActionResult Add(NetworkModel networkModel)
{
if (networkModel == null)
{
var errorMessage = _messages.GetMessage(Generic.NullObject);
return(BadRequest(errorMessage));
}
if (_networkRep.GetAll()
.Any(p => p.Name == networkModel.Name))
{
var errorMessage = _messages.GetMessage(Custom.Conflict, "Network", "Name");
return(Conflict(errorMessage));
}
_credentials.SetCredentials(Request.Headers.Authorization.Parameter);
var userId = _userRep.Get(_credentials.Email, _credentials.Password).Id;
var newNetwork = _mapper.Map <Network>(networkModel);
newNetwork.User_Id = userId;
newNetwork.Address = _guid.GetAddress();
newNetwork.ProductionDate = _dateTime.GetDateTime();
_networkRep.Add(newNetwork);
var createdNetwork = _mapper.Map <NetworkModelGet>(newNetwork);
return(CreatedAtRoute("GetNetwork",
new { id = createdNetwork.Id }, createdNetwork));
}
public IHttpActionResult Update(int id, NetworkModel networkModel)
{
if (networkModel == null)
{
var errorMessage = _messages.GetMessage(Generic.NullObject);
return(BadRequest(errorMessage));
}
if (_networkRep.GetAll()
.Any(p => p.Name == networkModel.Name && p.Id != id))
{
var errorMessage = _messages.GetMessage(Custom.Conflict, "Network", "Name");
return(Conflict(errorMessage));
}
var network = _networkRep.Get(id);
if (network == null)
{
var errorMessage = _messages.GetMessage(Custom.NotFound, "Network");
return(NotFound(errorMessage));
}
_mapper.Map(networkModel, network);
_networkRep.Update(network);
return(StatusCode(HttpStatusCode.NoContent));
}
static void DisplayActions(NetworkModel model, OxyPlot.Series.LineSeries series = null)
{
Console.WriteLine("\n\nActions:");
Console.WriteLine("[Any key] Run | [Q]uit | [S]ave | [D]elete");
Console.WriteLine("");
switch (Console.ReadKey(true).Key)
{
case ConsoleKey.Q:
{
Environment.Exit(0);
break;
}
case ConsoleKey.S:
{
SaveModel(model, series);
Environment.Exit(0);
break;
}
case ConsoleKey.D:
{
DeleteModel(model);
Environment.Exit(0);
break;
}
}
}
public NetworkModelService()
{
networkModel = new NetworkModel();
GenericDataAccess.NetworkModel = networkModel;
NMSTransactionActor.NetworkModel = networkModel;
InitializeHosts();
}
public NetworkModelDetailViewModel(object model)
{
if (model != null && model is NetworkModel)
{
m_model = model as NetworkModel;
}
}
public async Task <NetworkModel> GetReviewToReview(int UserId)
{
NetworkModel toReview = new NetworkModel();
try
{
if (CrossConnectivity.Current.IsConnected)
{
HttpClient httpClient = new HttpClient();
var uri = new Uri(string.Concat(Constants.baseUrl, "api/Favourates/ToReviewList?Id=" + UserId + "&PageNo=1"));
//var response = await httpClient.GetAsync(uri);
var requestTask = httpClient.GetAsync(uri);
var response = Task.Run(() => requestTask);
if (response.Result.IsSuccessStatusCode)
{
string result = await response.Result.Content.ReadAsStringAsync();
toReview = JsonConvert.DeserializeObject <NetworkModel>(result);
}
else
{
}
}
}
catch (Exception e)
{
Console.Write(e.StackTrace);
}
return(toReview);
}
/// <summary>
/// Runs the simulation, and an experiment (<see cref="IExperimentor"/>, if specified), and
/// applies a results transform (<see cref="IResultsTransform"/>, if specified). After simulation
/// has been run, the network can be retrieved for plotting/analysis.
/// </summary>
public void Execute()
{
simulator.PrepareNetwork(NetworkFilename);
if (!CacheNetwork || _initialNetwork == null)
{
_initialNetwork = simulator.GetNetworkModel();
Network = _initialNetwork;
}
//if we're supposed to be running an Experiment,
if (ExperimentDriver != null)
{
//Notify the Results Transformer of preliminary (pre-experiment)
// results.
if (ResultsTransformer != null)
{
ResultsTransformer.PreExperimentHook(_initialNetwork);
}
//Run the Experiment commands.
foreach (String str in ExperimentDriver.Experiment(_initialNetwork))
{
simulator.RunCommand(str);
}
//Solve the network again.
Network = simulator.GetNetworkModel();
}
//If we're using a Results Transformer, use it to finalise results.
if (ResultsTransformer != null)
{
ResultsTransformer.PostExperimentHook(Network);
}
}
/// <summary>
/// Draws all the network buses, using the specified value transforms.
/// </summary>
/// <param name="Network">The network from which to draw buses.</param>
/// <param name="colorMap">A map of the colours to use from the specified gradient.</param>
/// <param name="busSizeLimits">The limits of <see cref="BusSizeTransform"/>,
/// used for scaling from that space to
/// [<see cref="BusSizeMin"/>, <see cref="BusSizeMax"/>].</param>
/// <param name="ringColorPen">A pen for drawing rings.</param>
/// <param name="drawingContext">The target that we should draw to.</param>
protected void DrawBuses(NetworkModel Network, AdaptiveGradientMap <Tuple <Brush, Pen> > colorMap, Limits busSizeLimits, Pen ringColorPen, DrawingContext drawingContext)
{
//Draw all the buses.
foreach (var bus in Network.Buses.Values)
{
if (!(BusVisibleTransform(bus) && bus.Location.HasValue))
{
continue;
}
var bSize = busSizeLimits.ValueScaledToLimits(BusSizeTransform(bus));
//value-dependant fill, no outline, centre is scaled, radius of 2 (small dots).
drawingContext.DrawEllipse(
colorMap.Map(BusColorTransform(bus)).Item1,
null, ScaledLocation(bus.Location.Value), bSize, bSize);
//Bus Ring
if (RingEnabledTransform(bus))
{
var ringRadius = RingDistanceFromCenter ?
/*true*/ RingDistanceTransform(bus) :
/*false*/ bSize + RingDistanceTransform(bus);
drawingContext.DrawEllipse(null, ringColorPen,
ScaledLocation(bus.Location.Value), ringRadius, ringRadius);
}
}
}
/// <summary>
/// Draws all the network lines.
/// </summary>
/// <param name="Network">The network from which to draw buses.</param>
/// <param name="colorMap">A map of the colours to use from the specified gradient.</param>
/// <param name="drawingContext">The target that we should draw to.</param>
protected void DrawLines(NetworkModel Network, AdaptiveGradientMap <Tuple <Brush, Pen> > colorMap, DrawingContext drawingContext)
{
//Draw all the lines.
foreach (Line line in Network.Lines)
{
if (line.ConnectedTo.Count() != 2)
{
continue;
}
Bus bus1 = (Bus)line.ConnectedTo.ElementAt(0);
Bus bus2 = (Bus)line.ConnectedTo.ElementAt(1);
if (!(bus1.Location.HasValue && bus2.Location.HasValue))
{
continue;
}
//color based on average value.
var bCol1 = BusVisibleTransform(bus1) ? BusColorTransform(bus1) : 0;
var bCol2 = BusVisibleTransform(bus2) ? BusColorTransform(bus2) : 0;
double v_avg = (bCol1 + bCol2) / 2;
drawingContext.DrawLine(
colorMap.Map(v_avg).Item2, //choose the right color for the value
ScaledLocation(bus1.Location.Value), //scale the locations to image coordinates.
ScaledLocation(bus2.Location.Value)
);
}
}
public Task InsertNetwork(NetworkModel network)
{
string sql = @"insert into Network (ID, CCSD, Domain, CKT_Type, Source, SInt, SIP, Destination, DInt, DIP, CCO, Phone, DateAdded, AddedBy)
values (@ID, @CCSD, @Domain, @CKT_Type, @Source, @SInt, @SIP, @Destination, @DInt, @DIP, @CCO, @Phone, @DateAdded, @AddedBy)";
return(_db.SaveData(sql, network));
}
public TCPClient(IPEndPoint remoteEP, ParticipantModel participant, NetworkModel network, Guid serverID)
{
m_Connected = false;
m_Network = network;
m_Participant = participant;
m_LastMsgReceived = DateTime.MaxValue;
m_ServerId = serverID;
m_ClientTimeout = TimeSpan.FromMilliseconds(TCP_HEARTBEAT_TIMEOUT_DEFAULT_MS);
this.m_RemoteEP = remoteEP;
m_Socket = null;
m_ServerParticipant = null;
m_ReceiveQueue = new Queue();
this.m_Encoder = new Chunk.ChunkEncoder();
m_NetworkStatus = new NetworkStatus(ConnectionStatus.Disconnected, ConnectionProtocolType.TCP, TCPRole.Client, 0);
this.m_Network.RegisterNetworkStatusProvider(this, true, m_NetworkStatus);
//Find out if client-side bridging is enabled
m_BridgeEnabled = false;
string enableBridge = System.Configuration.ConfigurationManager.AppSettings[this.GetType().ToString() + ".EnableBridge"];
if (enableBridge != null)
{
bool enable = false;
if (bool.TryParse(enableBridge, out enable))
{
Trace.WriteLine("Unicast to Multicast Bridge enabled=" + enable.ToString(), this.GetType().ToString());
m_BridgeEnabled = enable;
}
}
}
public static void PlotDensity(NetworkModel networkModel)
{
var t = CreateRange(0, 0.0022, 0.00001);
var data = new List <Vector <double> >();
var labels = new List <string>();
data.Add(new Vector <double>(networkModel.ComputeDensity(networkModel.MinPath, 0, t)));
if (networkModel.MinPath.Length != networkModel.MaxPath.Length)
{
data.Add(new Vector <double>(networkModel.ComputeDensity(networkModel.MaxPath, 0, t)));
labels.Add(string.Format("Shortest path: {0}",
networkModel.MinPath.ToString(" -> ")));
labels.Add(string.Format("Longest path: {0}",
networkModel.MaxPath.ToString(" -> ")));
}
else
{
labels.Add(string.Format("Path: {0}",
networkModel.MinPath.ToString(" -> ")));
}
NPlotHelper.PlotCharts(data, t, labels);
}
private static void CountLine(ulong key, NetworkModel model)
{
foreach (var item in model.Substations)
{
if (item.Id == key)
{
item.counter++;
return;
}
}
foreach (var item in model.Nodes)
{
if (item.Id == key)
{
item.counter++;
return;
}
}
foreach (var item in model.Switches)
{
if (item.Id == key)
{
item.counter++;
return;
}
}
}
public NetworkModel GetNetworkStatus()
{
NetworkModel result = new NetworkModel(NetworkStatus.Disconnected, "0.0.0.0");
try
{
// order interfaces by speed and filter out down and loopback
// take first of the remaining
var firstUpInterface = NetworkInterface.GetAllNetworkInterfaces()
.OrderByDescending(c => c.Speed)
.FirstOrDefault(c => c.NetworkInterfaceType != NetworkInterfaceType.Loopback && c.OperationalStatus == OperationalStatus.Up);
if (firstUpInterface != null)
{
var props = firstUpInterface.GetIPProperties();
// get first IPV4 address assigned to this interface
var firstIpV4Address = props.UnicastAddresses
.Where(c => c.Address.AddressFamily == AddressFamily.InterNetwork)
.Select(c => c.Address)
.FirstOrDefault();
result = new NetworkModel(NetworkStatus.Connected, firstIpV4Address.ToString());
}
return(result);
}
catch (Exception exc)
{
//TODO: Handle Exception Here
return(result);
}
}
public void Add(Network network, User user)
{
var networkModel = NetworkModel.FromRepositoryType(network);
var userModel = UserModel.FromRepositoryType(user);
var sql = @"
INSERT
INTO NetworkGuestModels
(
Network_Id,
User_Id
)
VALUES
(
@Network_Id,
@User_Id
)
";
var parameters = new
{
Network_Id = networkModel.Id,
User_Id = userModel.Id,
};
_connection.Execute(sql, parameters);
}
public void TestAndGate()
{
NetworkModel model = new NetworkModel();
model.Layers.Add(new NeuralLayer(2, "INPUT"));
model.Layers.Add(new NeuralLayer(2, "HIDDEN"));
model.Layers.Add(new NeuralLayer(1, "OUTPUT"));
model.Build();
NeuralData X = new NeuralData(4);
X.Add(0, 0);
X.Add(0, 1);
X.Add(1, 0);
X.Add(1, 1);
NeuralData Y = new NeuralData(4);
Y.Add(0);
Y.Add(0);
Y.Add(0);
Y.Add(1);
// model.Train(X, Y, iterations: 10, learningRate: 0.1);
}
async void Start()
{
try
{
// Create a new instance of the network model class
// and asynchronously load the onnx model
_networkModel = new NetworkModel();
await _networkModel.LoadModelAsync();
StatusBlock.text = $"Loaded model. Starting camera...";
#if ENABLE_WINMD_SUPPORT
// Configure camera to return frames fitting the model input size
try
{
Debug.Log("Creating MediaCaptureUtility and initializing frame reader.");
_mediaCaptureUtility = new MediaCaptureUtility();
await _mediaCaptureUtility.InitializeMediaFrameReaderAsync(
(uint)InputFeatureSize.x, (uint)InputFeatureSize.y);
StatusBlock.text = $"Camera started. Running!";
Debug.Log("Successfully initialized frame reader.");
}
catch (Exception ex)
{
StatusBlock.text = $"Failed to start camera: {ex.Message}. Using loaded/picked image.";
}
// Run processing loop in separate parallel Task, get the latest frame
// and asynchronously evaluate
Debug.Log("Begin performing inference in frame grab loop.");
_isRunning = true;
await Task.Run(async() =>
{
while (_isRunning)
{
if (_mediaCaptureUtility.IsCapturing)
{
using (var videoFrame = _mediaCaptureUtility.GetLatestFrame())
{
await EvaluateFrame(videoFrame);
}
}
else
{
return;
}
}
});
#endif
}
catch (Exception ex)
{
StatusBlock.text = $"Error init: {ex.Message}";
Debug.LogError($"Failed to start model inference: {ex}");
}
}
/// <summary>
/// Add
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public NetworkModel Add(NetworkModel obj)
{
var c = IniFileHelper.ReadIniInt(_ini, "settings", "count") + 1;
IniFileHelper.WriteINI(_ini, c.ToString(), "description", obj.Description);
obj.NetworkID = c;
return(obj);
}
public static NetworkModel GetModel(string hostname)
{
var network = new NetworkModel();
network.hostname = hostname;
LinqFiles.SetFileText("/cfg/network/hostname", network.hostname);
return(network);
}
public void LoadElement()
{
NetworkModel networkModel = Deserialize("Geographic.xml");
substationEntities = networkModel.Substations;
switchEntities = networkModel.Switches;
nodeEntities = networkModel.Nodes;
lines = networkModel.Lines;
}
static void Main(string[] args)
{
Classes.NetworkModel model = new NetworkModel();
model.Layers.Add(new NeuralLayer(2, 0.1, "INPUT"));
model.Layers.Add(new NeuralLayer(2, 0.1, "HIDDEN"));
model.Layers.Add(new NeuralLayer(1, 0.1, "OUTPUT"));
model.Build();
}
public static bool FindFreeSpaceForSwitch(NetworkModel networkModel, UInt64[,] grid, int indexI, int indexJ, int i, out int freeI, out int freeJ)
{
bool spaceFound = false;
int step = 1;
while (!spaceFound)
{
if (grid[indexI, (indexJ - step) % 1000] == 0)
{
indexJ = (indexJ - step) % 1000;
grid[indexI, indexJ] = networkModel.Switches[i].Id;
spaceFound = true;
}
else if (grid[(indexI - step) % 1000, (indexJ - step) % 1000] == 0)
{
indexI = (indexI - step) % 1000;
indexJ = (indexJ - step) % 1000;
grid[indexI, indexJ] = networkModel.Switches[i].Id;
spaceFound = true;
}
else if (grid[(indexI - step) % 1000, indexJ] == 0)
{
indexI = (indexI - step) % 1000;
grid[indexI, indexJ] = networkModel.Switches[i].Id;
spaceFound = true;
}
else if (grid[indexI, (indexJ + step) % 1000] == 0)
{
indexJ = (indexJ + step) % 1000;
grid[indexI, indexJ] = networkModel.Switches[i].Id;
spaceFound = true;
}
else if (grid[(indexI + step) % 1000, (indexJ + step) % 1000] == 0)
{
indexI = (indexI + step) % 1000;
indexJ = (indexJ + step) % 1000;
grid[indexI, indexJ] = networkModel.Switches[i].Id;
spaceFound = true;
}
else if (grid[(indexI + step) % 1000, indexJ] == 0)
{
indexI = (indexI + step) % 1000;;
grid[indexI, indexJ] = networkModel.Switches[i].Id;
spaceFound = true;
}
if (++step == 16)
{
break;
}
}
freeI = indexI;
freeJ = indexJ;
return(spaceFound);
}
public ResponseModel GetNetwork(NetworkModel networkModel)
{
var _result = _instance.GetNetwork(networkModel);
return(new ResponseModel()
{
Response = JsonConvert.SerializeObject(_result), Success = true
});
}
public NMSGdaService(StatefulServiceContext context)
: base(context)
{
this.logger = CloudLoggerFactory.GetLogger(ServiceEventSource.Current, context);
Logger.LogInformation("GdaService Constructor started.");
this.networkModel = new NetworkModel(this.StateManager);
this.genericDataAccess = new GenericDataAccess(networkModel);
Logger.LogInformation("GdaService finished");
}
public ResponseModel SaveNetwork(NetworkModel objModel)
{
var _result = _instance.SaveNetwork(objModel);
return(new ResponseModel()
{
Response = _result.Response, Success = _result.Success.Value
});
}
public void Save(NetworkModel model, Db db)
{
db.Entry(model).State = Microsoft.EntityFrameworkCore.EntityState.Added;
db.SaveChanges();
db.Entry(model).GetDatabaseValues();
model.Layers.ToList().ForEach(x => x.NetworkID = model.ID);
model.Layers.ToList().ForEach(x => db.Entry(x).State = Microsoft.EntityFrameworkCore.EntityState.Added);
db.SaveChanges();
}
