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); }