public LinearFemAnalysis2DGeneral(Model model, ISolver solver)
{
if (model.SubdomainsDictionary.Count != 1)
{
throw new NotImplementedException(
"Cannot perform topology optimization with multiple subdomains yet.");
}
this.model = model;
subdomain = model.SubdomainsDictionary.First().Value;
this.solver = solver;
// Elements
IList <Element> modelElements = model.Elements;
NumElements = modelElements.Count;
elementTypes = new ContinuumElement2D[NumElements];
elementWrappers = new IElement[NumElements];
penalizers = new ScalingDofEnumerator[NumElements];
for (int e = 0; e < NumElements; ++e)
{
if (modelElements[e].ElementType is ContinuumElement2D continuum)
{
elementTypes[e] = continuum;
}
else
{
throw new ArgumentException("2D topology optimization only works with 2D continuum elements,"
+ $" but the element with ID = {modelElements[e].ID} was not.");
}
elementWrappers[e] = modelElements[e];
penalizers[e] = new ScalingDofEnumerator();
}
NumLoadCases = 1; //TODO: implement multiple load cases in Model, analyzers and solvers
}
public override List <Subdomain> GetSubdomains(string domainName)
{
var _tmp = new List <Subdomain>();
using (OleDbConnection _conn = new OleDbConnection(connectionString))
{
_conn.Open();
using (OleDbCommand _cmd = new OleDbCommand(@"SELECT Domain_Name, Sub_Domain, Host_ID, Reseller_Username FROM SubDomain_List
WHERE (Domain_Name = ?)", _conn))
{
_cmd.CommandType = CommandType.Text;
_cmd.Parameters.AddWithValue("NAME", domainName);
using (OleDbDataReader _read = _cmd.ExecuteReader())
{
while (_read.Read())
{
var _d = new Subdomain();
_d.Domain = _read["Domain_Name"].ToString();
_d.Login = _read["Domain_Name"].ToString();
_d.Password = "";
_d.Name = _read["Sub_Domain"].ToString();
_d.UserType = "";
_tmp.Add(_d);
}
}
}
_conn.Close();
}
return(_tmp);
}
/// <inheritdoc/>
public async Task SaveTerminalOutputParseAsync(RootDomain rootDomain, string agentName, bool activateNotification, ScriptOutput terminalOutputParse, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
// if we have a new rootdomain
if (!string.IsNullOrEmpty(terminalOutputParse.RootDomain) && !rootDomain.Name.Equals(terminalOutputParse.RootDomain))
{
rootDomain = new RootDomain
{
Name = terminalOutputParse.RootDomain,
Target = rootDomain.Target
};
await this.AddAsync(rootDomain, cancellationToken);
}
Subdomain subdomain = default;
if (await this.NeedAddNewSubdomain(rootDomain, terminalOutputParse.Subdomain, cancellationToken))
{
subdomain = await this.AddRootDomainNewSubdomainAsync(rootDomain, terminalOutputParse.Subdomain, agentName, cancellationToken);
if (activateNotification)
{
await this.notificationService.SendAsync(NotificationType.SUBDOMAIN, new[]
/// <summary>
/// <see cref="ITargetService.SaveScriptOutputAsync(Target, Subdomain, Agent, ScriptOutput, CancellationToken)"/>
/// </summary>
public async Task SaveScriptOutputAsync(Target target, Subdomain subdomain, Agent agent, ScriptOutput scriptOutput, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
if (subdomain != null)
{
try
{
this.UnitOfWork.BeginTransaction();
this.subdomainService.UpdateSubdomain(subdomain, agent, scriptOutput);
await this.UnitOfWork.CommitAsync();
}
catch (Exception)
{
this.UnitOfWork.Rollback();
}
}
if (subdomain == null || (subdomain != null && !subdomain.Name.Equals(scriptOutput.Subdomain, StringComparison.OrdinalIgnoreCase)))
{
await this.AddOrUpdateSubdomainAsync(target, agent, scriptOutput);
}
}
/// <summary>
/// Add or update the subdomain belong to the target
/// </summary>
/// <param name="rootDomain">The domain</param>
/// <param name="agent">The agent</param>
/// <param name="scriptOutput">The terminal output one line</param>
/// <returns>A Task</returns>
private async Task AddOrUpdateSubdomainAsync(RootDomain rootDomain, Agent agent, ScriptOutput scriptOutput, bool activateNotification, CancellationToken cancellationToken = default)
{
if (Uri.CheckHostName(scriptOutput.Subdomain) == UriHostNameType.Unknown)
{
return;
}
var subdomain = await this.subdomainService.GetAllQueryableByCriteria(d => d.Name == scriptOutput.Subdomain && d.RootDomain == rootDomain)
.Include(s => s.Services)
.FirstOrDefaultAsync();
if (subdomain == null)
{
subdomain = new Subdomain
{
Name = scriptOutput.Subdomain,
RootDomain = rootDomain
};
subdomain = await this.subdomainService.AddAsync(subdomain);
if (activateNotification && agent.NotifyNewFound && agent.AgentNotification != null && !string.IsNullOrEmpty(agent.AgentNotification.SubdomainPayload))
{
var payload = agent.AgentNotification.SubdomainPayload.Replace("{{domain}}", subdomain.Name);
await this.notificationService.SendAsync(payload, cancellationToken);
}
}
await this.SaveScriptOutputAsync(rootDomain, subdomain, agent, scriptOutput, activateNotification, cancellationToken);
}
public ICollection <SubdomainLabel> Resolve(SubdomainDto source, Subdomain destination, ICollection <SubdomainLabel> member, ResolutionContext context)
{
var SubdomainLabels = new List <SubdomainLabel>();
source.Labels.ForEach(l =>
{
var label = this.labelService.GetByCriteriaAsync(c => c.Name == l.Name).Result;
if (label != null)
{
SubdomainLabels.Add(new SubdomainLabel
{
LabelId = label.Id
});
}
else
{
SubdomainLabels.Add(new SubdomainLabel
{
Label = new Label
{
Name = label.Name
}
});
}
});
return(SubdomainLabels);
}
public SecurityContext Init(Func <IIdentity> identityGetter, Subdomain subdomain)
{
_identityGetter = identityGetter;
_isAuthenticated = TryGet(x => x.IsAuthenticated, false);
var username = TryCast(x => x.Name, string.Empty);
if (_isAuthenticated && !string.IsNullOrEmpty(username))
{
//if (subdomain == Subdomain.Backoffice || subdomain == Subdomain.Store)
//{
// //var client = TClient.FindByUsername(username);
// //var enabledAccess = TParameter.FindByEnum(subdomain == Subdomain.Backoffice ? Parameter.BlockAccessEV : Parameter.BlockAccessStore) == null;
// //if (client != null && enabledAccess)
// //_user = new UserSecurity(client, subdomain);
//}
//else
//{
// //var enabledAccess = TParameter.FindByEnum(subdomain == Subdomain.Painel ? Parameter.BlockAccessAdmin : Parameter.BlockAccessPDV) == null;
// //var model = TUser.FindByUsername(username);
// //if (model != null && (enabledAccess || username == "admin"))
// _user = new UserSecurity(model);
//}
}
else
{
_user = null;
}
if (_user == null)
{
_isAuthenticated = false;
}
return(this);
}
public async Task <bool> SetupSubdomainAsync(Guid domainId, SubdomainModel subdomainModel)
{
var domainName = (await _uow.DomainsRepository.Entities.FirstOrDefaultAsync(x => x.Id == domainId))?.Name;
var domainDirPath = $"{_ngixRootRoute}/{domainName}";
Directory.CreateDirectory(domainDirPath);
var subdomain = new Subdomain
{
Name = subdomainModel.Name,
ForceHttps = subdomainModel.ForceHttps,
IsDomainRoot = subdomainModel.IsDomainRoot,
Locations = subdomainModel.Locations.Select(l => new Location
{
Match = l.Match,
Modifier = l.Modifier,
Settings = l.Settings.Select(s => new LocationSetting
{
Directive = s.Directive,
Value = s.Value
}).ToList()
}).ToList()
};
using (var file = File.Create($"{domainDirPath}/{subdomain.Name}.conf"))
{
var bytes = Encoding.UTF8.GetBytes(_confGenerator.GenerateSubdomain(domainName, subdomain));
await file.WriteAsync(bytes, 0, bytes.Length);
}
return(true);
}
public virtual Dictionary <int, Element> GetBoundaryFiniteElementsDictionary(Subdomain subdomain, Dictionary <int, INode> boundaryNodes)
{
Dictionary <int, Element> subdomainBoundaryElements = new Dictionary <int, Element>();
foreach (Element element in subdomain.Elements)
{
bool containsBoundaryNode = false;
var elementDOFTypes = element.ElementType.DofEnumerator.GetDofTypesForMatrixAssembly(element);
var matrixAssemblyNodes = element.ElementType.DofEnumerator.GetNodesForMatrixAssembly(element);
for (int j = 0; j < elementDOFTypes.Count; j++)
{
INode elementNode = matrixAssemblyNodes[j];
if (boundaryNodes.ContainsKey(elementNode.ID))
{
containsBoundaryNode = true;
break;
}
}
if (containsBoundaryNode)
{
subdomainBoundaryElements.Add(element.ID, element);
}
}
return(subdomainBoundaryElements);
}
private void _btnSave_Click(object sender, EventArgs e)
{
_btnSave.Enabled = false;
Subdomain subdomain = new Subdomain();
subdomain.SubdomainName = _txtSubName.Text;
subdomain.DateFound = _dateFound.Value;
subdomain.DomainId = int.Parse(_cmbDomain.SelectedItem.ToString().Split('~')[1].ToString());
subdomain.FoundType = _txtFoundType.Text;
SubdomainController subController = new SubdomainController();
var res = subController.Insert(subdomain);
if (res.Error)
{
MessageBox.Show(res.Message);
}
else
{
_txtSubName.Text = "";
_dateFound.Value = DateTime.Now;
_cmbDomain.SelectedItem = "Select";
_txtFoundType.Text = "";
}
_btnSave.Enabled = true;
}
public async Task <ActionResult> StopAgent([FromBody] AgentRunnerDto agentRunnerDto, CancellationToken cancellationToken)
{
var agent = await agentService.GetByCriteriaAsync(a => a.Name == agentRunnerDto.Agent, cancellationToken);
if (agent == null)
{
return(BadRequest());
}
Target target = default;
if (!string.IsNullOrWhiteSpace(agentRunnerDto.Target))
{
target = await this.targetService.GetTargetNotTrackingAsync(t => t.Name == agentRunnerDto.Target, cancellationToken);
if (target == null)
{
return(BadRequest());
}
}
RootDomain rootDomain = default;
if (!string.IsNullOrWhiteSpace(agentRunnerDto.RootDomain))
{
rootDomain = await this.rootDomainService.GetRootDomainNoTrackingAsync(t => t.Name == agentRunnerDto.RootDomain && t.Target == target, cancellationToken);
if (rootDomain == null)
{
return(NotFound());
}
}
Subdomain subdomain = default;
if (!string.IsNullOrWhiteSpace(agentRunnerDto.Subdomain))
{
subdomain = await this.subdomainService
.GetAllQueryableByCriteria(s => s.RootDomain == rootDomain && s.Name == agentRunnerDto.Subdomain)
.AsNoTracking()
.SingleOrDefaultAsync(cancellationToken);
if (subdomain == null)
{
return(NotFound());
}
}
var agentRunner = new AgentRunner
{
Agent = agent,
Target = target,
RootDomain = rootDomain,
Subdomain = subdomain
};
await this.agentRunnerService.StopAgentAsync(agentRunner, cancellationToken);
return(NoContent());
}
public override List <Subdomain> GetSubdomains(string domainName)
{
var _tmp = new List <Subdomain>();
using (SQLiteConnection _conn = new SQLiteConnection(connectionString))
{
_conn.Open();
using (SQLiteCommand _cmd = new SQLiteCommand(@"SELECT SubDomain.Name, SubDomain.Username, Domain.Name AS DomainName
FROM Domain INNER JOIN SubDomain ON Domain.DomainId = SubDomain.DomainId
WHERE (Domain.Name = @NAME)", _conn))
{
_cmd.Parameters.AddWithValue("@NAME", domainName);
using (SQLiteDataReader _read = _cmd.ExecuteReader())
{
while (_read.Read())
{
var da = new Subdomain();
da.Domain = domainName;
da.Login = DataExtensions.GetColumnValue <String>(_read, "Username");
da.Name = DataExtensions.GetColumnValue <String>(_read, "Name");
da.Password = "";
_tmp.Add(da);
}
}
}
_conn.Close();
}
return(_tmp);
}
public override Task RouteAsync(RouteContext context)
{
var host = context.HttpContext.Request.Host.Value;
string foundHostname = GetHostname(host);
if (foundHostname == null && Subdomain != null)
{
return(Task.CompletedTask);
}
if (Subdomain == null)
{
if (foundHostname != null)
{
return(Task.CompletedTask);
}
return(base.RouteAsync(context));
}
var subdomain = host.Substring(0, host.IndexOf(GetHostname(host)) - 1);
if (!IsParameterName(Subdomain) && subdomain.ToLower() != Subdomain.ToLower())
{
return(Task.CompletedTask);
}
var parsedTemplate = TemplateParser.Parse(Subdomain);
//that's for overriding default for subdomain
if (IsParameterName(Subdomain) &&
Defaults.ContainsKey(ParameterNameFrom(Subdomain)) &&
!context.RouteData.Values.ContainsKey(ParameterNameFrom(Subdomain)))
{
context.RouteData.Values.Add(ParameterNameFrom(Subdomain), subdomain);
}
if (IsParameterName(Subdomain) &&
constraintsWithSubdomainConstraint.ContainsKey(ParameterNameFrom(Subdomain)))
{
if (!RouteConstraintMatcher.Match(
constraintsWithSubdomainConstraint,
new RouteValueDictionary
{
{ ParameterNameFrom(Subdomain), subdomain }
},
context.HttpContext,
this,
RouteDirection.IncomingRequest,
context.HttpContext.RequestServices.GetRequiredService <ILoggerFactory>().CreateLogger(typeof(RouteConstraintMatcher).FullName)))
{
return(Task.CompletedTask);
}
}
return(base.RouteAsync(context));
}
public async Task <ActionResult> StopAgent([FromBody] AgentRunnerDto agentRunnerDto, CancellationToken cancellationToken)
{
var agent = await agentService.GetByCriteriaAsync(a => a.Name == agentRunnerDto.Agent, cancellationToken);
if (agent == null)
{
return(BadRequest());
}
Target target = default;
if (!string.IsNullOrWhiteSpace(agentRunnerDto.Target))
{
target = await this.targetService.GetByCriteriaAsync(t => t.Name == agentRunnerDto.Target, cancellationToken);
if (target == null)
{
return(BadRequest());
}
}
RootDomain rootDomain = default;
if (!string.IsNullOrWhiteSpace(agentRunnerDto.RootDomain))
{
rootDomain = await this.rootDomainService.GetByCriteriaAsync(t => t.Name == agentRunnerDto.RootDomain && t.Target == target, cancellationToken);
if (rootDomain == null)
{
return(NotFound());
}
}
Subdomain subdomain = null;
if (!string.IsNullOrWhiteSpace(agentRunnerDto.Subdomain))
{
subdomain = await this.subdomainService.GetByCriteriaAsync(s => s.RootDomain == rootDomain && s.Name == agentRunnerDto.Subdomain, cancellationToken);
if (subdomain == null)
{
return(NotFound());
}
}
var agentRunner = new AgentRunner
{
Agent = agent,
Target = target,
RootDomain = rootDomain,
Subdomain = subdomain
};
var channel = AgentRunnerHelpers.GetChannel(agentRunner);
await this.agentRunnerService.StopAgentAsync(agentRunner, channel, cancellationToken);
return(NoContent());
}
/// <summary>
/// Run the Agent
/// </summary>
/// <param name="target">The target</param>
/// <param name="rootDomain"></param>
/// <param name="subdomain"></param>
/// <param name="agent"></param>
/// <param name="command"></param>
/// <param name="channel"></param>
/// <param name="activateNotification"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
private async Task RunAgentAsync(Target target, RootDomain rootDomain, Subdomain subdomain, Agent agent, string command, string channel, bool activateNotification, CancellationToken cancellationToken)
{
var commandToRun = this.GetCommand(target, rootDomain, subdomain, agent, command);
await this.connectorService.SendAsync("logs_" + channel, $"RUN: {command}");
await this.RunBashAsync(rootDomain, subdomain, agent, commandToRun, channel, activateNotification, cancellationToken);
}
public void IsNull_Passing_Valid_Value_Returns_False(string value)
{
var expected = false;
var actual = Subdomain.Create(value);
Assert.AreEqual(expected, actual.IsNull);
}
/// <summary>
/// Check if we need to skip the subdomain and does not the agent in that subdomain
/// </summary>
/// <param name="agent"></param>
/// <param name="subdomain"></param>
/// <returns></returns>
private bool NeedToSkipSubdomain(Agent agent, Subdomain subdomain)
{
var needToBeAlive = agent.OnlyIfIsAlive && (subdomain.IsAlive == null || !subdomain.IsAlive.Value);
var needTohasHttpOpen = agent.OnlyIfHasHttpOpen && (subdomain.HasHttpOpen == null || !subdomain.HasHttpOpen.Value);
var needToSkip = agent.SkipIfRanBefore && (!string.IsNullOrEmpty(subdomain.FromAgents) && subdomain.FromAgents.Contains(agent.Name));
return(needToBeAlive || needTohasHttpOpen || needToSkip);
}
public Factory(Model singleSubdomainModel, IDofOrderer originalDofOrderer,
Func <Model, ISolver, IStaticProvider> createProblemProvider)
{
this.singleSubdomainModel = singleSubdomainModel;
this.singleSubdomain = singleSubdomainModel.Subdomains.First();
this.originalDofOrderer = originalDofOrderer;
this.createProblemProvider = createProblemProvider;
}
public async Task <IActionResult> RunAgent([FromBody] AgentRunnerDto agentRunnerDto, CancellationToken cancellationToken)
{
var agent = await agentService.GetAgentToRunAsync(a => a.Name == agentRunnerDto.Agent, cancellationToken);
if (agent == null)
{
return(BadRequest());
}
Target target = default;
if (!string.IsNullOrWhiteSpace(agentRunnerDto.Target))
{
target = await this.targetService.GetTargetNotTrackingAsync(t => t.Name == agentRunnerDto.Target, cancellationToken);
if (target == null)
{
return(BadRequest());
}
}
RootDomain rootDomain = default;
if (!string.IsNullOrWhiteSpace(agentRunnerDto.RootDomain))
{
rootDomain = await this.rootDomainService.GetRootDomainNoTrackingAsync(t => t.Target == target && t.Name == agentRunnerDto.RootDomain, cancellationToken);
if (rootDomain == null)
{
return(NotFound());
}
}
Subdomain subdomain = default;
if (rootDomain != null && !string.IsNullOrWhiteSpace(agentRunnerDto.Subdomain))
{
subdomain = await this.subdomainService.GetSubdomainAsync(s => s.RootDomain == rootDomain && s.Name == agentRunnerDto.Subdomain, cancellationToken);
if (subdomain == null)
{
return(NotFound());
}
}
await this.agentRunnerService.RunAgentAsync(
new AgentRunner
{
Agent = agent,
Target = target,
RootDomain = rootDomain,
Subdomain = subdomain,
ActivateNotification = agentRunnerDto.ActivateNotification,
Command = agentRunnerDto.Command
}, cancellationToken);
return(NoContent());
}
public void OperatorEqual_Passing_Valid_Distinct_Values_Returns_False(string value)
{
var left = Subdomain.Create(value);
var right = Subdomain.Create("carlpopoos.ffff.ff");
var isEqual = left == right;
Assert.IsFalse(isEqual);
}
public void Change_Passing_Valid_Values_Returns_Subdomain()
{
var expected = "app.hackerone.com";
var actual = Subdomain.Create("stage.hackerone.com");
actual.Change(expected);
Assert.AreEqual(expected, actual.Value);
}
public void ToString_Passing_Valid_Values_Returns_Subdomain(string value)
{
var expected = value;
var result = Subdomain.Create(value);
var actual = result.ToString();
Assert.AreEqual(expected, actual);
}
public void Equals_Passing_Valid_Values_Returns_True(string value)
{
var left = Subdomain.Create(value);
var right = Subdomain.Create(value);
var isEqual = left.Equals(right);
Assert.IsTrue(isEqual);
}
public void OperatorNotEqual_Passing_Valid_Values_Returns_True(string value)
{
var left = Subdomain.Create(value);
var right = Subdomain.Create("carlos.fffff.ff");
var isEqual = left != right;
Assert.IsTrue(isEqual);
}
public void Equals_Passing_Valid_Distinct_Values_Returns_False(string value)
{
var left = Subdomain.Create(value);
var right = Subdomain.Create("pepe.dasdsad.rr");
var isEqual = left.Equals(right);
Assert.IsFalse(isEqual);
}
private static Model CreateSingleSubdomainModel(double stiffnessRatio)
{
// Replace the existing subdomains with a single one
Model model = CreateModel(stiffnessRatio);
model.SubdomainsDictionary.Clear();
var subdomain = new Subdomain(singleSubdomainID);
model.SubdomainsDictionary.Add(singleSubdomainID, subdomain);
foreach (Element element in model.Elements) subdomain.Elements.Add(element);
return model;
}
public static double[] CalculateFppReactionsVector(Subdomain subdomain, IElementMatrixProvider elementProvider,
IScaleTransitions scaleTransitions, Dictionary <int, INode> boundaryNodes, IVectorView solution, IVectorView dSolution,
Dictionary <int, Dictionary <IDofType, double> > initialConvergedBoundaryDisplacements, Dictionary <int, Dictionary <IDofType, double> > totalBoundaryDisplacements,
int nIncrement, int totalIncrements)
{
//TODOGerasimos: 1) Subdomain2 einai h upo kataskevh subdomain.cs ths Marias gia na mporoume na anaferthoume sthn methodo ths CalculateElementNodalDisplacements(..,..).
// Otan parei telikh morfh tha taftizetai me thn Subdomain.cs
// 2)IVector solution, IVector dSolution EINAI AFTA ME TA OPOIA kaloume thn GetRHSFromSolution sthn 213 tou NRNLAnalyzer
double[] FppReactionVector;
Dictionary <int, int> boundaryNodesOrder = GetNodesOrderInDictionary(boundaryNodes);
FppReactionVector = new double[boundaryNodesOrder.Count * scaleTransitions.PrescribedDofsPerNode()]; // h allliws subdomain.Forces.GetLength(0)
var times = new Dictionary <string, TimeSpan>();
var totalStart = DateTime.Now;
times.Add("rowIndexCalculation", DateTime.Now - totalStart);
times.Add("element", TimeSpan.Zero);
times.Add("addition", TimeSpan.Zero);
foreach (Element element in subdomain.Elements)
{
var isEmbeddedElement = element.ElementType is IEmbeddedElement;
var elStart = DateTime.Now;
//IMatrix2D ElementK = elementProvider.Matrix(element);
var localSolution = subdomain.GetLocalVectorFromGlobalWithoutPrescribedDisplacements(element, solution);
subdomain.ImposePrescribedDisplacementsWithInitialConditionSEffect(element, localSolution, boundaryNodes, initialConvergedBoundaryDisplacements, totalBoundaryDisplacements, nIncrement, totalIncrements);
double[] localdSolution = subdomain.GetLocalVectorFromGlobalWithoutPrescribedDisplacements(element, dSolution);
double[] f = element.ElementType.CalculateForces(element, localSolution, localdSolution);
times["element"] += DateTime.Now - elStart;
elStart = DateTime.Now;
var elementDOFTypes = element.ElementType.DofEnumerator.GetDofTypesForMatrixAssembly(element);
var matrixAssemblyNodes = element.ElementType.DofEnumerator.GetNodesForMatrixAssembly(element);
int iElementMatrixRow = 0;
for (int i = 0; i < elementDOFTypes.Count; i++)
{
INode nodeRow = matrixAssemblyNodes[i];
if (boundaryNodes.ContainsKey(nodeRow.ID))
{
for (int i1 = 0; i1 < scaleTransitions.PrescribedDofsPerNode(); i1++)
{
int dofrow_p = scaleTransitions.PrescribedDofsPerNode() * (boundaryNodesOrder[nodeRow.ID] - 1) + i1;
FppReactionVector[dofrow_p] += f[iElementMatrixRow + i1];
}
}
iElementMatrixRow += elementDOFTypes[i].Count;
}
times["addition"] += DateTime.Now - elStart;
}
var totalTime = DateTime.Now - totalStart;
return(FppReactionVector);
}
private Sparse2D <double> BuildQFromSubdomain(Subdomain subdomain)
{
Sparse2D <double> qSubdomain = new Sparse2D <double>(subdomain.TotalDOFs, subdomain.TotalDOFs);
foreach (Element element in subdomain.ElementsDictionary.Values)
{
if (!(element.ElementType is IPorousFiniteElement))
{
continue;
}
IPorousFiniteElement e = (IPorousFiniteElement)element.ElementType;
IMatrix2D <double> q = e.CouplingMatrix(element);
int iElementMatrixRow = 0;
for (int i = 0; i < element.ElementType.DOFEnumerator.GetDOFTypes(element).Count; i++)
{
Node nodeRow = element.Nodes[i];
foreach (DOFType dofTypeRow in element.ElementType.DOFEnumerator.GetDOFTypes(element)[i])
{
if (dofTypeRow != DOFType.Pore)
{
continue;
}
int dofRow = subdomain.NodalDOFsDictionary[nodeRow.ID][dofTypeRow];
if (dofRow != -1)
{
int iElementMatrixColumn = 0;
for (int j = 0; j < element.ElementType.DOFEnumerator.GetDOFTypes(element).Count; j++)
{
Node nodeColumn = element.Nodes[j];
foreach (DOFType dofTypeColumn in element.ElementType.DOFEnumerator.GetDOFTypes(element)[j])
{
if (dofTypeColumn == DOFType.Pore)
{
continue;
}
int dofColumn = subdomain.NodalDOFsDictionary[nodeColumn.ID][dofTypeColumn];
if (dofColumn != -1)
{
qSubdomain[dofColumn, dofRow] += q[iElementMatrixRow, iElementMatrixColumn];
}
iElementMatrixColumn++;
}
}
}
iElementMatrixRow++;
}
}
}
return(qSubdomain);
}
/// <summary>
/// Obtain the command to run on bash
/// </summary>
/// <param name="target">The target</param>
/// <param name="subdomain">The subdomain</param>
/// <param name="agent">The agent</param>
/// <returns>The command to run on bash</returns>
private string GetCommand(Target target, Subdomain subdomain, Agent agent, string command)
{
if (string.IsNullOrWhiteSpace(command))
{
command = agent.Command;
}
return($"{command.Replace("{{domain}}", subdomain == null ? target.RootDomain : subdomain.Name)}"
.Replace("{{targetName}}", target.Name)
.Replace("\"", "\\\""));
}
private static Subdomain DictionaryToDomain(Dictionary <string, Object> vals)
{
var subdomain = new Subdomain();
subdomain.SubdomainId = DatabaseUtilities.SafeMapToInt32(vals, "sub_domain_id");
subdomain.SubdomainName = DatabaseUtilities.SafeMapToString(vals, "sub_domain_name");
subdomain.DomainId = DatabaseUtilities.SafeMapToInt32(vals, "domain_id");
subdomain.DateFound = DatabaseUtilities.SafeMapToNullableDateTime(vals, "date_found");
subdomain.FoundType = DatabaseUtilities.SafeMapToString(vals, "found_type");
return(subdomain);
}
