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