/// <summary>
/// Проверяет корректность сетки
/// </summary>
/// <returns></returns>
public bool GridValidity()
{
bool IsCorrect = true;
#region Габаритные размеры должны соответствовать расчитанным по правилам разбиения по осям
decimal GridSizeXCalculated = StepTransition.StepTransitionListCalculateCoordinatesValidity(StepTransitionsX);
if (GridSizeXCalculated != GridSizeX)
{
IsCorrect = false;
}
decimal GridSizeYCalculated = StepTransition.StepTransitionListCalculateCoordinatesValidity(StepTransitionsY);
if (GridSizeYCalculated != GridSizeY)
{
IsCorrect = false;
}
decimal GridSizeZCalculated = StepTransition.StepTransitionListCalculateCoordinatesValidity(StepTransitionsZ);
if (GridSizeZCalculated != GridSizeZ)
{
IsCorrect = false;
}
#endregion
return(IsCorrect);
}
/// <summary>
/// Конструктор. Создаёт одномерную сетку с заданным по осям числом узлов
/// </summary>
/// <param name="gridSize">Размер расчетной области</param>
/// <param name="numNodes">Количество узлов</param>
public Grid1D(decimal gridSize, uint numNodes, AxisEnum axisEnum = AxisEnum.X)
{
AxisEnum = axisEnum;
GridSize = gridSize;
StepTransition st = new StepTransition(numNodes, gridSize / (numNodes - 1), gridSize);
StepTransitions.Add(st);
}
/// <summary>
/// Конструктор. Создаёт одномерную сетку с заданным по осям числом узлов
/// </summary>
/// <param name="gridSize">Размер расчетной области</param>
/// <param name="numNodes">Количество узлов</param>
public Grid2D(decimal gridSize1, decimal gridSize2, uint numNodes1, uint numNodes2, AxisEnum axisEnum1 = AxisEnum.X, AxisEnum axisEnum2 = AxisEnum.Y)
{
AxisEnum1 = axisEnum1;
AxisEnum2 = axisEnum2;
GridSize1 = gridSize1;
GridSize2 = gridSize2;
StepTransition st1 = new StepTransition(numNodes1, gridSize1 / (numNodes1 - 1), gridSize1);
StepTransitions1.Add(st1);
StepTransition st2 = new StepTransition(numNodes2, gridSize2 / (numNodes2 - 1), gridSize2);
StepTransitions1.Add(st2);
}
/// <summary>
/// Вычисляет размер по списку переходов
/// </summary>
/// <param name="StepTransitionList"></param>
/// <returns></returns>
public static decimal StepTransitionListCalculateCoordinatesValidity(List <StepTransition> StepTransitionList)
{
StepTransition prevStep = null;
decimal size = 0;
foreach (var step in StepTransitionList)
{
if (prevStep != null)
{
size += (step.Index - prevStep.Index) * step.StepValue;
}
else
{
size += step.Index * step.StepValue;
}
prevStep = step;
}
return(size);
}
/// <summary>
/// Создаёт список слоёв на основе переданного списка переходов
/// </summary>
/// <param name="stepTransitionList">Список переходов (список List объектов StepTransition)</param>
/// <returns>Список объектов GridLayer</returns>
public static List <GridLayer> GenerateGridLayerListFromStepTransitionList(List <StepTransition> stepTransitionList)
{
var resultGridLayerList = new List <GridLayer>();
uint resultGridLayerListItemIndex = 0;
if (stepTransitionList == null)
{
return(resultGridLayerList);
}
if (stepTransitionList.Count == 0)
{
return(resultGridLayerList);
}
StepTransition prevStepTransition = new StepTransition(0, 0, 0);
GridLayer prevLayer = new GridLayer();
prevLayer.Index = 0;
prevLayer.Coordinate = 0;
resultGridLayerList.Add(prevLayer);
for (int stepTransitionCounter = 0; stepTransitionCounter < stepTransitionList.Count; stepTransitionCounter++)
{
StepTransition currentStepTransition = stepTransitionList[stepTransitionCounter];
decimal distanceBetweenStepTransitions = currentStepTransition.Coordinate - prevStepTransition.Coordinate;
uint numLayersBetweenStepTransitions = Convert.ToUInt32(distanceBetweenStepTransitions / currentStepTransition.StepValue);
for (int layerCounter = 0; layerCounter < numLayersBetweenStepTransitions; layerCounter++)
{
GridLayer curLayer = new GridLayer();
curLayer.Index = ++resultGridLayerListItemIndex;
curLayer.Coordinate = prevLayer.Coordinate + currentStepTransition.StepValue;
resultGridLayerList.Add(curLayer);
prevLayer = curLayer;
}
prevStepTransition = currentStepTransition;
}
return(resultGridLayerList);
}
/// <summary>
/// Конструктор. Создаёт сетку с заданным по осям числом узлов
/// </summary>
/// <param name="GridSizeX">Размер расчетной области по оси X</param>
/// <param name="GridSizeY">Размер расчетной области по оси Y</param>
/// <param name="GridSizeZ">Размер расчетной области по оси Z</param>
/// <param name="NumX">Количество участков по оси X</param>
/// <param name="NumY">Количество участков по оси Y</param>
/// <param name="NumZ">Количество участков по оси Z</param>
public Grid3D(decimal GridSizeX,
decimal GridSizeY,
decimal GridSizeZ,
uint NumX,
uint NumY,
uint NumZ)
{
this.GridSizeX = GridSizeX;
this.GridSizeY = GridSizeY;
this.GridSizeZ = GridSizeZ;
StepTransition stX = new StepTransition(NumX, GridSizeX / NumX, GridSizeX);
StepTransitionsX.Add(stX);
StepTransition stY = new StepTransition(NumY, GridSizeY / NumY, GridSizeY);
StepTransitionsY.Add(stY);
StepTransition stZ = new StepTransition(NumZ, GridSizeZ / NumZ, GridSizeZ);
StepTransitionsZ.Add(stZ);
}
/// <summary>
/// Генерирует списки слоёв из объекта Grid
/// </summary>
/// <param name="grid">Объект сетки Grid</param>
private void InsertGridLayersFromGrid(Grid2D grid)
{
GridLayers2D.GridLayers1 = StepTransition.GenerateGridLayerListFromStepTransitionList(grid.StepTransitions1);
GridLayers2D.GridLayers2 = StepTransition.GenerateGridLayerListFromStepTransitionList(grid.StepTransitions2);
}
/// <summary>
/// Генерирует списки слоёв из объекта Grid
/// </summary>
/// <param name="grid">Объект сетки Grid</param>
private void InsertGridLayersFromGrid(Grid1D grid)
{
GridLayers1D.GridLayers = StepTransition.GenerateGridLayerListFromStepTransitionList(grid.StepTransitions);
}
public void CorrectIndexes()
{
StepTransition.CorrectIndexesInStepTransition(StepTransitions);
}
/// <summary>
/// Добавить слой сетки в заданной координате
/// </summary>
/// <param name="coordinate">Координата вставки</param>
/// <returns>Объект переходов StepTransition</returns>
public static StepTransition InsertNode(decimal coordinate, List <StepTransition> StepTransitionList)
{
/* Вставку слоя моделируем добавлением правила
* перехода шагов сетки по оси с корректировкой смежных шагов
* ----------i----------j-------K---l----------
*
* Графическая интерпретация
* 0 1 2 3 - индексы StepTransitions
* 15 23 29 30 - StepTransitions[i].Index
* 5 4 3 1 - StepTransitions[i].StepValue
* 0 - - - - 5 - - - - 10 - - - - 15 - - - 19 - - - 23 - - 26 - - 29 30 ... - индексы слоёв
* - координаты слоёв
*
* Вставка
*/
StepTransition prevStepTransition = null;
StepTransition curStepTransition = null;
StepTransition nextStepTransition = null;
int?prevStepTransitionListIndex = null;
int?nextStepTransitionListIndex = null;
for (int i = 0; i <= StepTransitionList.Count; i++)
{
// Если переданная координата совпадает с существующим переходом,
// новый переход не создаём, а возвращаем существующий
if (StepTransitionList[i].Coordinate == coordinate)
{
return(StepTransitionList[i]);
}
// Поиск первого перехода, координата которого
// превышает переданное значение
if (StepTransitionList[i].Coordinate > coordinate)
{
// Определяем индексы переходов слева и справа
nextStepTransitionListIndex = i;
nextStepTransition = StepTransitionList[i];
if (i > 0)
{
prevStepTransitionListIndex = i - 1;
prevStepTransition = StepTransitionList[i - 1];
}
break;
}
}
// Возможны три варианта расположения нового слоя:
// 1 - до первого перехода: предыдущий = null, следующий = 0
// 2 - между существующими переходами: предыдущий > = 0, следующий < StepTransitions.Count
// 3 - за границей расчетной области: предыдущий = StepTransitions.Count, следующий = null
// Если координата превышает габаритные размеры расчетной области, возвращаем null
// Обработка 3 варианта: новый слой расположен за пределами расчетной области,
// возвращаем null
if (nextStepTransitionListIndex == null)
{
return(null);
}
// Обработка 1 варианта: новый слой расположен до первого перехода
if (prevStepTransitionListIndex == null)
{
prevStepTransition = new StepTransition(0, 0, 0);
}
// Обработка 2 варианта: новый слой расположен между существующими переходами
// Добавление узла
// Определяем узлы слева и справа от места вставки.
// Возможны 4 варианта:
// 1) добавляемый узел совпадает с существующим - ничего не делаем
// 2) левый узел - переход
// 3) левый и правый узлы - не переходы
// 4) правый узел - переход
StepTransition prevNodeAsStepTransition = new StepTransition();
StepTransition nextNodeAsStepTransition = new StepTransition();
// Расстояние от левого перехода до координаты добавляемого слоя
decimal d = coordinate - prevStepTransition.Coordinate;
// Количество слоёв от левого перехода до координаты
decimal dLayers = d / nextStepTransition.StepValue;
uint dLayersUINT = (uint)Decimal.Truncate(dLayers);
// Детектор совпадения координаты добавляемого слоя с имеющимися
decimal sovpadenie = d % nextStepTransition.StepValue;
// 1 вариант. Добавляемый слой совпадает с существующим - ничего не делаем
if (sovpadenie == 0m)
{
return(null);
}
// 2 вариант. Левый слой - переход
// - добавляем текущий переход по переданной координате
if (dLayers < 1)
{
prevNodeAsStepTransition = prevStepTransition;
curStepTransition = new StepTransition(prevNodeAsStepTransition.Index + 1,
coordinate - prevNodeAsStepTransition.Coordinate,
coordinate);
nextNodeAsStepTransition = new StepTransition(curStepTransition.Index + 1,
prevNodeAsStepTransition.Coordinate + nextStepTransition.StepValue - coordinate,
prevNodeAsStepTransition.Coordinate + nextStepTransition.StepValue);
// Правый слой может оказаться переходом!
if (nextNodeAsStepTransition.Coordinate == nextStepTransition.Coordinate)
{
StepTransitionList.Insert((int)nextStepTransitionListIndex,
curStepTransition);
nextStepTransition.Coordinate = nextNodeAsStepTransition.Coordinate;
nextStepTransition.Index = nextNodeAsStepTransition.Index;
nextStepTransition.StepValue = nextNodeAsStepTransition.StepValue;
if (curStepTransition.Index == 1)
{
CorrectIndexesInStepTransition(StepTransitionList);
}
else if (nextStepTransition.Index != StepTransitionList[StepTransitionList.Count - 1].Index)
{
IncreaseIndexesInStepTransition(StepTransitionList, nextNodeAsStepTransition.Index, 1);
}
}
else
{
StepTransitionList.InsertRange((int)nextStepTransitionListIndex,
new List <StepTransition> {
curStepTransition, nextNodeAsStepTransition
});
IncreaseIndexesInStepTransition(StepTransitionList, nextNodeAsStepTransition.Index + 1, 1);
}
return(curStepTransition);
}
// 3) левый и правый слои - не переходы
if (dLayers < ((nextStepTransition.Coordinate - prevStepTransition.Coordinate) / nextStepTransition.StepValue - 1))
{
prevNodeAsStepTransition = new StepTransition(prevStepTransition.Index + dLayersUINT,
nextStepTransition.StepValue,
prevStepTransition.Coordinate + nextStepTransition.StepValue * dLayersUINT);
curStepTransition = new StepTransition(prevNodeAsStepTransition.Index + 1,
coordinate - prevNodeAsStepTransition.Coordinate,
coordinate);
nextNodeAsStepTransition = new StepTransition(curStepTransition.Index + 1,
prevNodeAsStepTransition.Coordinate + nextStepTransition.StepValue - coordinate,
prevNodeAsStepTransition.Coordinate + nextStepTransition.StepValue);
StepTransitionList.InsertRange((int)nextStepTransitionListIndex,
new List <StepTransition> {
prevNodeAsStepTransition, curStepTransition, nextNodeAsStepTransition
});
IncreaseIndexesInStepTransition(StepTransitionList, nextNodeAsStepTransition.Index + 1, 1);
return(curStepTransition);
}// 4) правый слой - переход
else
{
prevNodeAsStepTransition = new StepTransition(prevStepTransition.Index + dLayersUINT,
nextStepTransition.StepValue,
prevStepTransition.Coordinate + nextStepTransition.StepValue * dLayersUINT);
curStepTransition = new StepTransition(prevNodeAsStepTransition.Index + 1,
coordinate - prevNodeAsStepTransition.Coordinate,
coordinate);
nextNodeAsStepTransition = nextStepTransition;
nextNodeAsStepTransition.Index++;
nextNodeAsStepTransition.StepValue = nextNodeAsStepTransition.Coordinate - curStepTransition.Coordinate;
StepTransitionList.InsertRange((int)nextStepTransitionListIndex,
new List <StepTransition> {
prevNodeAsStepTransition, curStepTransition
});
IncreaseIndexesInStepTransition(StepTransitionList, nextNodeAsStepTransition.Index + 1, 1);
return(curStepTransition);
}
}
public void CorrectIndexes()
{
StepTransition.CorrectIndexesInStepTransition(StepTransitionsX);
StepTransition.CorrectIndexesInStepTransition(StepTransitionsY);
StepTransition.CorrectIndexesInStepTransition(StepTransitionsZ);
}
/// <summary>
/// Добавить слой сетки XY в заданной координате Z
/// </summary>
/// <param name="coordinate"></param>
/// <returns></returns>
public StepTransition InsertLayerZ(decimal coordinate)
{
return(StepTransition.InsertNode(coordinate, StepTransitionsZ));
}
/// <summary>
/// Генерирует списки слоёв из объекта Grid
/// </summary>
/// <param name="grid">Объект сетки Grid</param>
private void InsertGridLayersFromGrid(Grid3D grid)
{
GridLayers3D.GridLayersX = StepTransition.GenerateGridLayerListFromStepTransitionList(grid.StepTransitionsX);
GridLayers3D.GridLayersY = StepTransition.GenerateGridLayerListFromStepTransitionList(grid.StepTransitionsY);
GridLayers3D.GridLayersZ = StepTransition.GenerateGridLayerListFromStepTransitionList(grid.StepTransitionsZ);
}
