async public Task <IActionResult> Run(string roomId, FunctionCallViewModel fcall)
{
var normalisedRoomId = roomId.ToUpperInvariant();
if (!RoomRepository.Exists(normalisedRoomId))
{
return(NotFound("Room not found"));
}
var room = RoomRepository.Get(normalisedRoomId);
return(await RoomHelpers.WithRoomLock <IActionResult>(room, async() =>
{
if (room.Library == null)
{
return base.BadRequest();
}
if (!room.Library.GetFunctionList().Any(f => f.Name == fcall.Name))
{
return base.NotFound("Function not found");
}
var results = room.Library.Call(fcall.Name, fcall.Arguments);
ResultGroup resultGroup = GroupResults(results);
await ResultPublisher.Publish(room, resultGroup);
return base.Ok();
}));
}
private string FormatResultGroup(ResultGroup resultGroup)
{
var results = resultGroup.Results
.Select(r => FormatResult(r.Result))
.Where(r => r != null);
return(string.Join("\n ", results));
}
async public Task Publish(Room room, ResultGroup resultGroup)
{
string discordWebHook = room.State.DiscordWebHook;
if (!string.IsNullOrEmpty(discordWebHook))
{
await PublishOnDiscord(discordWebHook, resultGroup);
}
room.State.Results.Add(resultGroup);
await RoomHub.Update(room);
}
public void RemoveProcessor <TInput, TResult>(IScanProcessor <TInput, TResult> processor) where TInput : class
{
if (processors.ContainsKey(typeof(TInput)))
{
List <BaseProcessorWrapper> list = processors[typeof(TInput)];
list.RemoveAll((BaseProcessorWrapper wrapper) => wrapper.Processor == processor);
}
if (resultProviders.ContainsKey(typeof(TResult)))
{
ResultGroup <TResult> resultGroup = (ResultGroup <TResult>)resultProviders[typeof(TResult)];
resultGroup.RemoveProcessor(processor);
}
}
private List <ResultGroup> GroupMessages(IEnumerable <LogEntry> logs)
{
List <ResultGroup> res = new List <ResultGroup>();
var currentDay = DateTime.MinValue;
ResultGroup currentGroup = null;
foreach (var message in logs)
{
if (message.When.Date != currentDay)
{
currentDay = message.When.Date;
currentGroup = new ResultGroup
{
Title = "Messages of " + currentDay.ToString("dd.MM.yyyy"),
Actions = new List <ResultAction>(),
};
res.Add(currentGroup);
}
if (message is LogEntry.ChatMessage)
{
currentGroup.Actions.Add(new ResultAction
{
Type = "Chat",
Content = ((LogEntry.ChatMessage)message).Message,
ActorName = message.Who.Name,
ActorId = message.Who.Id,
Time = message.When.ToString("o")
});
}
else
{
string type = (message is LogEntry.Connected) ? "Connected" : "Disconnected";
currentGroup.Actions.Add(new ResultAction
{
Type = type,
ActorName = message.Who.Name,
ActorId = message.Who.Id,
Time = message.When.ToString("o")
});
}
}
return(res);
}
private ResultGroup GroupResults(IList <Result> results)
{
var taggedResults = results.Select(r => new TaggedResult
{
Result = r,
ResultType = GetResultType(r),
}).ToList();
var resultGroup = new ResultGroup
{
Results = taggedResults,
Created = DateTime.UtcNow,
User = SessionManager.GetCurrentUser()
};
return(resultGroup);
}
// Get: Results grouped together by Event
public ViewResult GroupedResults()
{
var events = _context.Result
.GroupBy(e => e.EventId)
.Select(g => new { id = g.Key, count = g.Count() });
List <ResultGroup> lRg = new List <ResultGroup>();
foreach (var gRes in events)
{
Event e2 = _context.Event.Where(x => x.EventId == gRes.id).FirstOrDefault();
ResultGroup rg = new ResultGroup()
{
_Event = e2, ResultCount = gRes.count
};
lRg.Add(rg);
}
return(View(lRg));
}
private void ConfirmMergeDataGroupButton_Click(object sender, RoutedEventArgs e)
{
ResultGroup resultGroup = MergeTargetGroupComboBox.SelectedItem as ResultGroup;
if (resultGroup == MainPage.allResult.CurrentGroup())
{
ShowAlertDialogAsync("You need to merge two different groups!");
goto End;
}
if (resultGroup is null)
{
ShowAlertDialogAsync("Please selete target group!");
goto End;
}
App.MainPageInstance.MergeResultGroup(resultGroup);
End:
MergeDataGroupNameButton.Flyout.Hide();
}
private void AddBaseProcessor <TInput, TResult>(IScanProcessor <TInput, TResult> processor) where TInput : class
{
if (!processors.ContainsKey(typeof(TInput)))
{
processors.Add(typeof(TInput), new List <BaseProcessorWrapper>());
}
List <BaseProcessorWrapper> list = processors[typeof(TInput)];
if (!list.Exists((BaseProcessorWrapper wrapper) => wrapper.Processor == processor))
{
list.Add(MakeWrapper(processor));
}
if (!resultProviders.ContainsKey(typeof(TResult)))
{
resultProviders.Add(typeof(TResult), new ResultGroup <TResult>());
}
ResultGroup <TResult> resultGroup = (ResultGroup <TResult>)resultProviders[typeof(TResult)];
resultGroup.AddProcessor(processor);
}
private async Task PublishOnDiscord(string discordWebHook, ResultGroup resultGroup)
{
var resultMarkDown = FormatResultGroup(resultGroup);
var viewModel = new DiscordMessageViewModel
{
UserName = resultGroup.User.Name,
Embeds = new List <DiscordEmbedViewModel>
{
new DiscordEmbedViewModel {
Description = resultMarkDown
}
}
};
var options = new JsonSerializerOptions
{
PropertyNamingPolicy = new LowerCaseNamingPolicy(),
};
var serialized = JsonSerializer.Serialize(viewModel, options);
var response = await HttpClient.PostAsync(
discordWebHook,
new StringContent(serialized, Encoding.UTF8, "application/json"));
Logger.LogInformation(response.StatusCode.ToString());
}
/// <summary>
/// Simplifies and combines the matrix
/// </summary>
/// <returns>Result group collection instance</returns>
public ResultGroupCollection Simplify()
{
var vectors = new VectorCollection();
foreach (var elm in Matrix.Keys)
{
var vect = vectors.GetVectorByKey(elm.Name);
if (vect == null)
{
vect = new Vector {
Key = elm.Name
};
vectors.Add(vect);
}
vect.Values.Add(Matrix[elm]);
}
var maxValues = vectors.GetMaxCountValues();
var resultGroups = new ResultGroupCollection();
while (maxValues > 0)
{
if (vectors.Count == 1)
{
var rgroup = new ResultGroup();
rgroup.Keys.Add(vectors[0].Key);
rgroup.Values.AddRange(vectors[0].Values);
resultGroups.Add(rgroup);
}
else
{
var rgroup = new ResultGroup();
for (var i = 0; i < vectors.Count; i++)
{
var vecX = vectors[i];
for (var j = i + 1; j < vectors.Count; j++)
{
var vecY = vectors[j];
var elementsCoincidentes = new List <string>();
var numIgualdades = 0;
foreach (var elmX in vecX.Values)
{
foreach (var elmY in vecY.Values)
{
if (elmX != elmY)
{
continue;
}
numIgualdades++;
if (!elementsCoincidentes.Contains(elmX))
{
elementsCoincidentes.Add(elmX);
}
}
}
if (numIgualdades == maxValues)
{
if (rgroup.Values.Count == 0)
{
rgroup.Values.AddRange(elementsCoincidentes);
rgroup.Keys.Add(vecX.Key);
rgroup.Keys.Add(vecY.Key);
}
else
{
var igualdadesgrupo = 0;
foreach (var elmX in rgroup.Values)
{
foreach (var elmY in elementsCoincidentes)
{
if (elmX == elmY)
{
igualdadesgrupo++;
}
}
}
if (igualdadesgrupo != maxValues)
{
if (rgroup.Keys.Count > 0)
{
resultGroups.Add(rgroup);
}
rgroup = new ResultGroup();
rgroup.Values.AddRange(elementsCoincidentes);
rgroup.Keys.Add(vecX.Key);
rgroup.Keys.Add(vecY.Key);
}
else if (igualdadesgrupo == maxValues)
{
var xAdded = false;
foreach (var key in rgroup.Keys)
{
if (key == vecX.Key)
{
xAdded = true;
}
}
if (!xAdded)
{
rgroup.Keys.Add(vecX.Key);
}
var yAdded = false;
foreach (var key in rgroup.Keys)
{
if (key == vecY.Key)
{
yAdded = true;
}
}
if (!yAdded)
{
rgroup.Keys.Add(vecY.Key);
}
}
}
}
else
{
if (maxValues == vecX.Values.Count && maxValues > vecY.Values.Count)
{
if (rgroup.Keys.Count > 0 && !resultGroups.ContainsRGroup(vecX))
{
resultGroups.Add(rgroup);
}
rgroup = new ResultGroup();
rgroup.Values.AddRange(vecX.Values);
rgroup.Keys.Add(vecX.Key);
}
if (maxValues == vecY.Values.Count && maxValues > vecX.Values.Count)
{
if (rgroup.Keys.Count > 0 && !resultGroups.ContainsRGroup(vecY))
{
resultGroups.Add(rgroup);
}
rgroup = new ResultGroup();
rgroup.Values.AddRange(vecY.Values);
rgroup.Keys.Add(vecY.Key);
}
}
}
}
if (rgroup.Keys.Count > 0 && rgroup.Values.Count > 0)
{
resultGroups.Add(rgroup);
}
}
maxValues--;
}
return(resultGroups);
}
/***************************************************/
// Read results for 2D elements from the output file.
public static void Read2DElementResults(Model model, ResultGroup resultType, int step = 0, double totalTime = 1.0)
{
if (model.Panels.Count == 0)
{
return;
}
// Find Ids of 2D elements.
List <int> nonComposite2DIds = new List <int>();
foreach (Element e in model.Mesh.Elements)
{
if (e is Element2D && !(e as Element2D).Composite)
{
nonComposite2DIds.Add(e.Id.AsInteger);
}
}
if (nonComposite2DIds.Count == 0)
{
return;
}
// Read result lines.
string[] resLines = File.ReadAllLines(model.GetModelFilePath(GuanacoUtil.FileType.frd));
string line;
// Find ids of vertices of each element.
List <int[]> vertIds = new List <int[]>();
int elCount = 0;
bool elInfo = false;
for (int i = 0; i < resLines.Length; i++)
{
line = resLines[i].TrimStart(' ');
if (!elInfo && line.StartsWith("3C"))
{
elInfo = true;
continue;
}
else if (elInfo && line.StartsWith("-1"))
{
int elId = int.Parse(line.Split(GuanacoUtil.Space, StringSplitOptions.RemoveEmptyEntries)[1]) - 1;
if (elId == nonComposite2DIds[elCount])
{
Element2D e = model.Mesh.Elements[elId] as Element2D;
i++;
line = resLines[i].TrimStart(' ');
int[] splt = line.Split(GuanacoUtil.Space, StringSplitOptions.RemoveEmptyEntries).Skip(1).Select(s => int.Parse(s)).ToArray();
vertIds.Add(splt.Take(e.PrimaryNodeCount * 2).ToArray());
elCount++;
if (elCount == nonComposite2DIds.Count)
{
break;
}
}
}
else if (elInfo && line.StartsWith("-3"))
{
break;
}
}
// Read the results per each vertex.
Dictionary <int, double[]> nodeValues = new Dictionary <int, double[]>();
int resid = GetFirstResultLine(resLines, resultType, GuanacoUtil.FileType.frd, step, totalTime);
line = resLines[resid];
string start = "-1";
while (start == "-1")
{
int nodeId = int.Parse(line.Substring(4, 9));
double[] nodeValue = new double[6];
int i = 13;
for (int j = 0; j < 6; j++)
{
string resultString = line.Substring(i, 12);
double resultValue = double.NaN;
if (double.TryParse(resultString, GuanacoUtil.FloatNum, GuanacoUtil.Invariant, out resultValue))
{
nodeValue[j] = resultValue;
}
else if (resultString.Substring(9) == "INF")
{
nodeValue[j] = resultString[8] == '-' ? double.NegativeInfinity : double.PositiveInfinity;
}
else
{
throw new Exception("The result format is incorrect, please inspect the result .frd file.");
}
i += 12;
}
nodeValues.Add(nodeId, nodeValue);
resid++;
line = resLines[resid];
start = line.Substring(1, 2);
}
// Assign the values to the elements.
for (int i = 0; i < nonComposite2DIds.Count; i++)
{
Element2D e = model.Mesh.Elements[nonComposite2DIds[i]] as Element2D;
int vertCount = vertIds[i].Length;
Type type = null;
switch (resultType)
{
case ResultGroup.Stress:
type = typeof(Stress2D);
break;
case ResultGroup.Strain:
type = typeof(Strain2D);
break;
}
string[] names = Enum.GetNames(type).Skip(1).ToArray();
foreach (string name in names)
{
if (!e.Results.ContainsKey(name))
{
e.AddResult(name, new double[vertCount]);
}
}
for (int j = 0; j < vertCount; j++)
{
double[] vertValues = nodeValues[vertIds[i][j]];
for (int k = 0; k < names.Length; k++)
{
e.Results[names[k]][j] = vertValues[k];
}
}
}
}
/***************************************************/
// Find first line containing results in a result file.
public static int GetFirstResultLine(string[] resLines, ResultGroup resultGroup, GuanacoUtil.FileType fileType, int step = 0, double totalTime = 1.0)
{
int lineNo = -1;
int stepCount = 1;
double time = 0;
switch (fileType)
{
case GuanacoUtil.FileType.dat:
{
string resultName = string.Empty;
switch (resultGroup)
{
case ResultGroup.Displacement:
{
resultName = "displacements";
break;
}
case ResultGroup.Strain:
{
resultName = "strains";
break;
}
case ResultGroup.Stress:
{
resultName = "stresses";
break;
}
}
for (int i = 0; i < resLines.Length; i++)
{
if (resLines[i].TrimStart(' ').StartsWith(resultName))
{
{
string[] splt = resLines[i].Split(GuanacoUtil.Space, StringSplitOptions.RemoveEmptyEntries);
time = double.Parse(splt[splt.Length - 1], GuanacoUtil.FloatNum);
lineNo = i + 2;
if (stepCount == step)
{
return(lineNo);
}
stepCount++;
}
}
}
break;
}
case GuanacoUtil.FileType.frd:
{
string resultName = string.Empty;
switch (resultGroup)
{
case ResultGroup.Stress:
{
resultName = "STRESS";
break;
}
case ResultGroup.Strain:
{
resultName = "TOSTRAIN";
break;
}
}
for (int i = 0; i < resLines.Length; i++)
{
int minLength = 5 + resultName.Length;
if (resLines[i].Length > minLength && resLines[i].Substring(5, resultName.Length) == resultName)
{
{
string[] splt = resLines[i - 1].Split(GuanacoUtil.Space, StringSplitOptions.RemoveEmptyEntries);
time = double.Parse(splt[2], GuanacoUtil.FloatNum);
int j = i;
while (j < resLines.Length)
{
if (resLines[j].Substring(1, 2) == "-1")
{
lineNo = j;
break;
}
j++;
}
if (stepCount == step)
{
return(lineNo);
}
stepCount++;
}
}
}
break;
}
}
if (time != totalTime)
{
throw new Exception("Oooops, the iteration did not converge!");
}
return(lineNo);
}
private static void PerformTestByTesterAndSample(Type testerType, SampleDataSet <Orders> sampleDataset, ResultGroup resultGroup, int testsToPerform)
{
for (var i = 1; i <= testsToPerform; i++)
{
// Create the new tester
var ctor = testerType.GetConstructor(new[] { typeof(SampleDataSet <Orders>) });
var tester = (Tester <Orders>)ctor.Invoke(new object[] { sampleDataset });
// Run test
Console.WriteLine(String.Format("Testing {0} [Sample Size: {1}]...", tester.Name, tester.SampleDataSet.Size));
tester.Test();
// Collect results
resultGroup.Results.Add(tester.GetResult());
// Clean up any unused/unreferenced resources.
tester.Dispose();
GC.Collect();
}
}
