private void SortAndSweepZ(TaskParams parameters) { Array.Clear(_matrixZ, 0, _matrixZ.Length); if (_newItems > 0) { _axisZ.Sort(_zCompare); } else { InsertSortZ(); } for (int i = 0; i < _axisZ.Count; i++) { for (int j = i + 1; j < _axisZ.Count; j++) { Composition ci = _axisZ[i], cj = _axisZ[j]; if (ci.BoundingBox.Maximum.Z >= cj.BoundingBox.Minimum.Z) { int row = (int)(ci.Flags < cj.Flags ? ci.Flags : cj.Flags); int col = (int)(ci.Flags < cj.Flags ? cj.Flags : ci.Flags); _matrixZ[row, col / sizeof(uint)] |= (uint)(1 << (col % sizeof(uint))); } else { break; } } } }
public async Task OnTasks(TaskParams parameters) { var ctx = Context; await ctx.Channel.TriggerTypingAsync(); if (parameters.User == null) { parameters.User = ctx.User.Username; } if (parameters.Status == null) { parameters.Status = JiraStatus.InProgress; } var jql = parameters.ToJQL(); List <Issue> tasks; try { tasks = await AgileBot.Atlassian.GetAllJiraIssuesForUser(jql, parameters.Max); } catch (Exception except) { await ctx.Channel.SendMessageAsync($"Exception: {except.Message}"); return; } if (tasks.Count != 0) { var iter = tasks.GetEnumerator(); iter.MoveNext(); var key = iter.Current.Key.ToString(); var titleUrl = new Uri($"{AgileBot.Atlassian.JiraClient.Url}browse/{key}?jql={jql}"); var linkName = $"**{key}**: {iter.Current.Summary}"; var user = iter.Current.AssigneeUser; var msg = $"{GetHyperlink(linkName, AgileBot.Atlassian.GetURLForIssue(iter.Current.Key))}"; while (iter.MoveNext()) { key = iter.Current.Key.ToString(); linkName = $"**{key}**: { iter.Current.Summary}"; msg += $"\n{GetHyperlink(linkName, AgileBot.Atlassian.GetURLForIssue(iter.Current.Key))}"; } var builder = new EmbedBuilder(); string avatarUrl = string.Empty; string author = parameters.title; if (user != null) { avatarUrl = user.AvatarUrls.Large; author = string.Format(parameters.title, user.DisplayName); } builder.WithAuthor(author, avatarUrl, titleUrl.AbsoluteUri); builder.WithDescription(msg); builder.WithColor(AtlassianClient.JiraBlue); await ctx.Channel.SendMessageAsync(embed : builder.Build()); } else { await ctx.Channel.SendMessageAsync("No tasks found."); } }
public override TaskExecutionResult executeTask(TaskParams taskParams) { try { if (File.Exists(taskParams.values[TaskParam.PARAM_SOURCE_FILE_NAME].getValue())) { try { File.Copy( taskParams.values[TaskParam.PARAM_SOURCE_FILE_NAME].getValue(), taskParams.values[TaskParam.PARAM_DEST_FILE_NAME].getValue() ); } catch (Exception err) { return TaskExecutionResult.exceptionResult(TaskErrors.EXCEPTION, err); } return TaskExecutionResult.successfullResult(); } else return TaskExecutionResult.errorResult(TaskErrors.ERROR_FILE_NOT_EXISTS, taskParams.values[TaskParam.PARAM_SOURCE_FILE_NAME]); } catch (Exception err) { return TaskExecutionResult.exceptionResult(TaskErrors.EXCEPTION, err); } }
public void AsyncReadStringFromFile() { IsBusy = true; TaskParams ReadTaskParams = new TaskParams(2000, 11, null); //A SimulationDelay + TaskID Task ReadTask = new Task(ReadFromFile, ReadTaskParams); ReadTask.Start(); }
public RESTQueryResponse <Models.Task> Get() { //var query = @"active=true^u_resolved=false"; var param = new TaskParams(); var result = _taskService.GetRecordByQuery(param); return(result); }
public CallbackDelegate callbackDelegate = null; // Step 2 "Create delegate object...ICH" public void AsyncWriteStringToFile(string _string) { IsBusy = true; TaskParams WriteTaskParams = new TaskParams(2000, 10, _string); //A SimulationDelay + TaskID + String to write to file Task WriteTask = new Task(WriteToFile, WriteTaskParams); WriteTask.Start(); }
public void run() { TaskParams taskParams = new TaskParams(2000, 666); Task taskD = new Task(FireDelegate, taskParams); // I like this one!!!, to bad i cant pass the taskD.Id taskD.Start(); taskD.Wait(); }
private bool isTaskSet() { TaskParams taskParams = client.GetTaskState(new TaskParams() { Name = TaskName }); return(taskParams != null && taskParams.IsSet); }
public void run() { TaskParams taskParams = new TaskParams(2000, 666); Task taskD = new Task(FireEvent, taskParams); // I like this one!!!, to bad i cant pass the taskD.Id taskD.Start(); taskD.Wait(); //Debug.WriteLine($" TaskD id = {taskD.Id}"); }
public void Should_create_wmi_client_lowercase() { var taskParams = new TaskParams { Type = "wmi", Sql = "sql", ConnectionString = "cs", Path = "path" }; var o = clientFactory.Create(taskParams); Assert.That(o, Is.Not.Null); Assert.That(o, Is.TypeOf(typeof(WmiClient))); Assert.That(o, Is.TypeOf<WmiClient>()); }
public void Should_create_sql_server_client() { var taskParams = new TaskParams { Type = "SqlServer", Sql = "sql", ConnectionString = "cs", Path = "path" }; var o = clientFactory.Create(taskParams); Assert.That(o, Is.Not.Null); Assert.That(o, Is.TypeOf(typeof(SqlServerClient))); Assert.That(o, Is.TypeOf<SqlServerClient>()); }
public override int OnRunTask(TaskParams @params) { EMessageType messageType = (EMessageType)@params.Extras.GetByte(WifiP2pConstants.ExtraWifiP2pMessageType); switch (messageType) { case EMessageType. } }
private void ProcessMesh(object voxelParameters) { TaskParams voxelParams = (TaskParams) voxelParameters; Vector3 voxelCenter = voxelParams.VoxelCenter; int voxelId = voxelParams.VoxelId; int[] triangles = voxelParams.Triangles; Vector3[] verticesWS = voxelParams.VerticesWS; Vector3[] trianglesNormals = voxelParams.TrianglesNormals; Color[] colors = voxelParams.Colors; Vector2[] uvs = voxelParams.UVs; Vector3 voxelMinPosition = voxelCenter - m_VoxelHalfDimensions; Vector3[] triangleVertices = new Vector3[3]; for (int triangleId = 0; triangleId < triangles.Length; triangleId += 3) { int vertexId1 = triangles[triangleId]; int vertexId2 = triangles[triangleId + 1]; int vertexId3 = triangles[triangleId + 2]; // Triangle vertices with respect to voxel. triangleVertices[0] = verticesWS[vertexId1] - voxelMinPosition; triangleVertices[1] = verticesWS[vertexId2] - voxelMinPosition; triangleVertices[2] = verticesWS[vertexId3] - voxelMinPosition; Vector3 triangleNormal = trianglesNormals[triangleId / 3]; if (MathHelper.CheckAABBAndTriangleIntersection(m_VoxelVertices[0], m_VoxelVertices[7], triangleVertices, m_VoxelVertices, triangleNormal)) { Vector2 uv = Vector2.zero; Color color = Material.Color; // Get mesh properties (color, uv) from first vertex in triangle and set to voxel. if (uvs.Length > 0) { uv = uvs[vertexId1]; } if (colors.Length > 0) { color *= colors[vertexId1]; } VoxelRenderer.Voxel voxel = new VoxelRenderer.Voxel { Center = voxelCenter, Size = m_VoxelSize, Color = new Vector3(color.r, color.g, color.b), UV = uv, }; m_Voxels[voxelId] = voxel; break; } } }
public async Task <IActionResult> GetAllHighPriorityTasks(bool status, [FromQuery] TaskParams taskParams) { var HighPriorityTasks = await _repo.GetAllHighPriorityTasks(status, taskParams); //add the pagination information in the response header Response.AddPagination(HighPriorityTasks.CurrentPage, HighPriorityTasks.PageSize, HighPriorityTasks.TotalCount, HighPriorityTasks.TotalPages); return(Ok(HighPriorityTasks)); }
public async Task <IActionResult> GetTaskByCustomerAll(int customerId, [FromQuery] TaskParams taskParams) { var customerTasks = await _repo.GetAllTaskByCustomer(customerId, taskParams); //add the pagination information in the response header Response.AddPagination(customerTasks.CurrentPage, customerTasks.PageSize, customerTasks.TotalCount, customerTasks.TotalPages); return(Ok(customerTasks)); }
public ISqlClient Create(TaskParams taskParams) { var type = taskParams.Type.ToLower(); if (type == "wmi") { return new WmiClient(log, taskParams); } return new SqlServerClient(log, taskParams); }
public async void PrintMethodThreadSleepWithId(object?_taskParams) //See Task API. { TaskParams taskParams = (TaskParams)_taskParams; //Vid prod kod skall det såklart in try/catch på flera ställen. while (true) { await Task.Delay(taskParams.DelayTime); Debug.WriteLine($"PrintMethodThreadSleepWithId {taskParams.TaskId}"); } }
public async void ReadFromFile(object?_taskParams) //See Task API, måste ta emot object :( { TaskParams taskParams = (TaskParams)_taskParams; Debug.WriteLine($" Im Task with id={taskParams.TaskId}. I dont want to lock your GUI/UX when i do my stuffNow. I will callback when im done "); await Task.Delay(taskParams.DelayTime); // Simulating... Console.WriteLine(await File.ReadAllTextAsync("myFile.txt")); callbackDelegate("Read operation"); // Step 3 "Raise the delegate event, and pass this string, I wonder if anyone is listening :) IsBusy = false; }
public async void FireEvent(object?_taskParams) { TaskParams taskParams = (TaskParams)_taskParams; //Vid prod kod skall det såklart in try/catch på flera ställen. while (true) { await Task.Delay(taskParams.DelayTime); //Debug.WriteLine($"FireEvent {taskParams.TaskId}"); EventArgs emptyEventArgs = new EventArgs(); this.MyEvent(this, emptyEventArgs); //Alright, dags att höja flaggan, kanske lyssnar någon eller inte, det är iof inget jag oroar mig för. } }
public async void FireDelegate(object?_taskParams) { TaskParams taskParams = (TaskParams)_taskParams; //Vid prod kod skall det såklart in try/catch på flera ställen. while (true) { await Task.Delay(taskParams.DelayTime); //Debug.WriteLine($"FireEvent {taskParams.TaskId}"); EventArgs emptyEventArgs = new EventArgs(); string MyString = "HEJ "; Search(); // Varje gång denna anropas, låtsas vi att vi har hittat en fil vi letat efter. } }
//High priority tasks by time public async Task <PagedList <TaskSchedule> > GetHighPriorityTasks( DateTime startDate, DateTime endDate, bool status, TaskParams taskParams) { DateTime endDateAdjust = endDate.AddDays(1); var query = _context.TaskSchedules .Where(t => t.Start >= startDate && t.End <= endDateAdjust) .Where(h => h.highPriority == true) .Where(s => s.isClosed == status) .Include(c => c.customer) .Include(u => u.userCurrentAssigned) .AsNoTracking(); //gets sent to the pagination methods to be paginated return(await PagedList <TaskSchedule> .CreateAsync(query, taskParams.Pagenumber, taskParams.PageSize)); }
public async Task <IEnumerable <ToDo> > getToDos(string userName, TaskParams taskParams) { var toDos = dataContext.ToDos.Where(t => t.User.UserName == userName).AsQueryable(); if (taskParams.Status != null) { if (taskParams.Status == "done") { toDos = toDos.Where(t => t.IsDone); } if (taskParams.Status == "todo") { toDos = toDos.Where(t => !t.IsDone); } } return(await toDos.OrderByDescending(t => t.CreateDate).ToListAsync()); }
public async Task <IActionResult> GetTasks(string userName, [FromQuery] TaskParams taskParams) { if (userName != (User.FindFirst(ClaimTypes.Name).Value)) { return(Unauthorized()); } var tasks = await toDoRepository.getToDos(userName, taskParams); if (tasks != null) { var tasksToReturn = mapper.Map <IEnumerable <TaskForReturnDto> >(tasks); return(Ok(tasksToReturn)); } return(BadRequest()); }
//public async Task<IActionResult> GetTaskSchedule(int staffId) public async Task <IActionResult> GetTaskSchedulesByUser(int userId, [FromQuery] TaskParams taskParams) { var taskScheduled = await _repo.GetTask(2); int tokenUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); if (userId == tokenUserId || User.IsInRole("Admin")) { var taskSchedule = await _repo.GetTaskSchedulesByUser(userId, taskParams); var taskReturn = _mapper.Map <IEnumerable <getTaskScheduleDto> >(taskSchedule); //add the pagination information in the response header Response.AddPagination(taskSchedule.CurrentPage, taskSchedule.PageSize, taskSchedule.TotalCount, taskSchedule.TotalPages); return(Ok(taskReturn)); } return(Unauthorized()); }
public override TaskExecutionResult executeTask(TaskParams taskParams) { try { if (File.Exists(taskParams.values[TaskParam.PARAM_FILE_NAME].getValue())) { File.Delete(taskParams.values[TaskParam.PARAM_FILE_NAME].getValue()); return TaskExecutionResult.successfullResult(); } else return TaskExecutionResult.errorResult(TaskErrors.ERROR_FILE_NOT_EXISTS, taskParams.values[TaskParam.PARAM_FILE_NAME]); } catch (Exception err) { return TaskExecutionResult.errorResult(err.Message); } }
private void TaskEntryPoint(TaskParams rawData) { TaskParams taskParams = rawData; try { string sessionId = openSession(taskParams.UserId); int c = 10; while (c > 0) { Thread.Sleep(taskParams.DelayMs); sendNextRequest(sessionId); --c; } } catch (Exception ex) { Console.WriteLine(String.Format("Exception in thread userid:{0} : {1}\r\nThread exits", taskParams.UserId, ex.Message)); } }
public void Start() { int threadsCount = Int32.Parse(ConfigurationManager.AppSettings["ClientThreads"]); int delayMs = Int32.Parse(ConfigurationManager.AppSettings["SendDelayMs"]); List <Task> tasks = new List <Task>(); for (int i = 0; i < threadsCount; ++i) { TaskParams taskParams = new TaskParams(); taskParams.DelayMs = delayMs + i * 50; // making different delays taskParams.UserId = 100 + i; Task task = Task.Run(() => TaskEntryPoint(taskParams)); tasks.Add(task); Console.WriteLine(string.Format("Task {0} started", taskParams.UserId)); } Thread.Sleep(5000); Task.WaitAll(tasks.ToArray()); }
public void DelayMethodA() { Thread.CurrentThread.Name = "ThreadClassA"; Debug.WriteLine($"Hello from thread running DelayMethodA in ThreadClassA : { Thread.CurrentThread.Name} "); Task taskA = new Task(() => Console.WriteLine("")); taskA.Start(); Debug.WriteLine($" TaskA id = {taskA.Id}"); Task taskB = new Task(() => Console.WriteLine("")); taskB.Start(); Debug.WriteLine($" TaskB id = {taskB.Id}"); Task taskC = new Task(PrintMethodThreadSleep); Debug.WriteLine($" TaskC id = {taskC.Id}"); taskC.Start(); TaskParams taskDParams = new TaskParams(2000, 666); Task taskD = new Task(PrintMethodThreadSleepWithId, taskDParams); // I like this one!!!, to bad i cant pass the taskD.Id taskD.Start(); Debug.WriteLine($" TaskD id = {taskD.Id}"); TaskParams taskEParams = new TaskParams(1000, 667); Task taskE = new Task(PrintMethodThreadSleepWithId, taskEParams); taskE.Start(); Debug.WriteLine($" TaskE id = {taskE.Id}"); taskE.Wait(); taskD.Wait(); taskC.Wait(); taskA.Wait(); taskB.Wait(); }
public async Task OnBugs(TaskParams parameters) { if (parameters.User == null) { parameters.title = "Bugs!"; } else { parameters.title = "Bugs for {0}"; } if (parameters.Status == null) { parameters.Status = string.Empty; } parameters.PreJql = $"(status = \"{JiraStatus.OpenBug}\" OR status = \"{JiraStatus.InProgress}\")"; parameters.Type = JiraIssueType.Bug; if (parameters.User == null) { parameters.User = string.Empty; } await OnTasks(parameters); }
// Logic for task execution public override int OnRunTask(TaskParams @params) { Log.Debug(LOG_TAG, "Starting"); try { System.Threading.Tasks.Task.Run(async() => { try { ViewModelBase.Init(true); // Download data var manager = DependencyService.Get <IStoreManager> (); if (manager == null) { return; } await manager.SyncAllAsync(Settings.Current.IsLoggedIn); Android.Util.Log.Debug(LOG_TAG, "Succeeded"); Settings.Current.LastSync = DateTime.UtcNow; Settings.Current.HasSyncedData = true; } catch (Exception ex) { Android.Util.Log.Debug(LOG_TAG, ex.Message); } }).Wait(TimeSpan.FromSeconds(60)); } catch { } Log.Debug(LOG_TAG, "Ending"); return(GcmNetworkManager.ResultSuccess); }
// Logic for task execution public override int OnRunTask(TaskParams @params) { Log.Debug (LOG_TAG, "Starting"); try { System.Threading.Tasks.Task.Run (async () => { try { ViewModelBase.Init (); // Download data var manager = DependencyService.Get<IStoreManager> (); if (manager == null) return; await manager.SyncAllAsync (Settings.Current.IsLoggedIn); Android.Util.Log.Debug (LOG_TAG, "Succeeded"); Settings.Current.LastSync = DateTime.UtcNow; Settings.Current.HasSyncedData = true; } catch (Exception ex) { Android.Util.Log.Debug (LOG_TAG, ex.Message); } }).Wait(TimeSpan.FromSeconds(60)); } catch { } Log.Debug (LOG_TAG, "Ending"); return GcmNetworkManager.ResultSuccess; }
public async Task <IActionResult> GetTasksWithinHoursWorked(int userId, DateTime startDate, DateTime endDate, [FromQuery] TaskParams taskParams) { int tokenUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); if (userId == tokenUserId || User.IsInRole("Admin")) { var tasksWorkedWithinHours = await _repo.GetTasksWithinHoursWorkedRepo(userId, startDate, endDate, taskParams); //add the pagination information in the response header Response.AddPagination(tasksWorkedWithinHours.CurrentPage, tasksWorkedWithinHours.PageSize, tasksWorkedWithinHours.TotalCount, tasksWorkedWithinHours.TotalPages); return(Ok(tasksWorkedWithinHours)); } return(Unauthorized()); }
public void Process(TaskParams parameters) { this.Process(); }
public override TaskExecutionResult executeTask(TaskParams taskParams) { return TaskExecutionResult.defaultResult(); }
public SqlClientBase(ILog log, TaskParams taskParams) { this.Log = log; this.TaskParams = taskParams; }
private void CreateVoxels(bool doAsync) { if (m_MeshRenderer != null && m_MeshFilter != null) { Mesh mesh = m_MeshFilter.sharedMesh; int[] triangles = mesh.triangles; Color[] colors = mesh.colors; Vector2[] uvs = mesh.uv; // mesh vertices in World Space Vector3[] verticesWS; Vector3[] trianglesNormals; InitializeVerticesAndNormals(m_MeshRenderer.transform, mesh.vertices, triangles, out verticesWS, out trianglesNormals); Bounds meshBoundsWS = m_MeshRenderer.bounds; Vector3Int meshDimensionInVoxels = Vector3Int.CeilToInt(meshBoundsWS.size / m_VoxelSize); Vector3 voxelsInitialPosition = meshBoundsWS.min + m_VoxelHalfDimensions; // To avoid issues manipulating the voxels list within threads, this array of voxels will be used. // Each voxel will write to their corresponding id. m_Voxels = new VoxelRenderer.Voxel[meshDimensionInVoxels.x * meshDimensionInVoxels.y * meshDimensionInVoxels.z]; if(doAsync) { m_Tasks.Clear(); } int currentVoxelID = -1; for (int x = 0; x < meshDimensionInVoxels.x; ++x) { for (int y = 0; y < meshDimensionInVoxels.y; ++y) { for (int z = 0; z < meshDimensionInVoxels.z; ++z) { currentVoxelID++; Vector3 voxelCenter = voxelsInitialPosition + new Vector3(x, y, z) * m_VoxelSize; TaskParams taskParams = new TaskParams() { VoxelCenter = voxelCenter, VoxelId = currentVoxelID, Triangles = triangles, VerticesWS = verticesWS, TrianglesNormals = trianglesNormals, Colors = colors, UVs = uvs }; if (doAsync) { m_Tasks.Add(Task.Factory.StartNew(ProcessMesh, taskParams)); } else { ProcessMesh(taskParams); } } } } if(doAsync) { Task t = Task.WhenAll(m_Tasks); t.Wait(); } Voxels = m_Voxels.Select(v => v).Where(v => v.Size != 0).ToList(); } }
internal virtual void WritePair(TaskParams parameters) { this.WritePair((Composition)parameters.Param1, (Composition)parameters.Param2); }
public TaskExecutionResult executeTask(SimpleTask simpleTask, TaskParams taskParams) { simpleTask.startTask(); TaskExecutionResult taskResult = simpleTask.executeTask(taskParams); simpleTask.endTask(); return taskResult; }
private void FormatMatr(double tim, RiverParams riverModel, TaskParams taskParams) { double length = riverModel.LengthByX / riverModel.SplitsNumberByX; double x1, x2, xkv, zn, iser; for (int i = 0; i < Fun.Length; i++) { Fun[i] = 0; } for (int i = 0; i < MatrC.Length; i++) { MatrC[i] = 0; } for (int i = 0; i <= riverModel.SplitsNumberByX - 1; i++) { x1 = i * riverModel.LengthByX / riverModel.SplitsNumberByX; x2 = (i + 1) * riverModel.LengthByX / riverModel.SplitsNumberByX; if (i < (riverModel.SplitsNumberByX - 1) / 2) { iser = taskParams.AngleOfInclinationSine; } else { iser = taskParams.AngleSine; } for (int it = 0; it <= 3; it++) { for (int j = 0; j <= 1; j++) { xkv = (x1 + x2) / 2 + KvadrX[it] * (x2 - x1) / 2; for (int k = 0; k <= 1; k++) { zn = length * KvadrC[it] * (Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) + beta * timeIncrease * (Uj(xkv, riverModel) * dFi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) + dUj(xkv, riverModel) * Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel))); MatrC[GetNum(2 * (i + k), 2 * (i + j))] = MatrC[GetNum(2 * (i + k), 2 * (i + j))] + zn; zn = beta * timeIncrease * length * KvadrC[it] * (Fj(xkv, riverModel) * dFi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) + dFj(xkv, riverModel) * Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel)); MatrC[GetNum(2 * (i + k), 2 * (i + j) + 1)] = MatrC[GetNum(2 * (i + k), 2 * (i + j) + 1)] + zn; zn = length * KvadrC[it] * (beta * timeIncrease * dFi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) / taskParams.FreeSurfaceWidth + ((taskParams.Alpha - 1) * (Uj(xkv, riverModel) / Fj(xkv, riverModel)) * Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel)) / taskParams.GravityAcceleration); MatrC[GetNum(2 * (i + k) + 1, 2 * (i + j))] = MatrC[GetNum(2 * (i + k) + 1, 2 * (i + j))] + zn; zn = length * KvadrC[it] * (Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) / taskParams.GravityAcceleration + beta * timeIncrease * (taskParams.Alpha / taskParams.GravityAcceleration * dUj(xkv, riverModel) * Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) + 1 / taskParams.GravityAcceleration * Uj(xkv, riverModel) * dFi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) + (2 / (taskParams.ShaziCoefficient * taskParams.ShaziCoefficient * taskParams.ChannelHydraulicRadius)) * Uj(xkv, riverModel) * Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel))); MatrC[GetNum(2 * (i + k) + 1, 2 * (i + j) + 1)] = MatrC[GetNum(2 * (i + k) + 1, 2 * (i + j) + 1)] + zn; } zn = -length * KvadrC[it] * (Fj(xkv, riverModel) * dUj(xkv, riverModel) * Fi(i + j, xkv, riverModel) + dFj(xkv, riverModel) * Uj(xkv, riverModel) * Fi(i + j, xkv, riverModel)); Fun[2 * (i + j)] = Fun[2 * (i + j)] + zn; zn = -length * KvadrC[it] * (dFj(xkv, riverModel) * Fi(i + j, xkv, riverModel) / taskParams.FreeSurfaceWidth + taskParams.Alpha / taskParams.GravityAcceleration * Uj(xkv, riverModel) * dUj(xkv, riverModel) * Fi(i + j, xkv, riverModel) - iser * Fi(i + j, xkv, riverModel) + Uj(xkv, riverModel) * Uj(xkv, riverModel) * Fi(i + j, xkv, riverModel) / (taskParams.ShaziCoefficient * taskParams.ShaziCoefficient * taskParams.ChannelHydraulicRadius)); Fun[2 * (i + j) + 1] = Fun[2 * (i + j) + 1] + zn; } } } for (int i = 0; i < Fun.Length; i++) { FF[i] = Fun[i]; } MatrC[GetNum(0, 0)] = mnoz; MatrC[GetNum(1, 1)] = mnoz; FF[0] = Gr_umF * mnoz; FF[1] = Gr_umU * mnoz; }
public virtual TaskExecutionResult executeTask(TaskParams taskParams) { return TaskExecutionResult.defaultResult(); }
internal virtual void WritePair(TaskParams parameters) { this.WritePair((Composition)parameters.Param1, (Composition)parameters.Param2); }