/// <summary>
/// Testa a existencia de um KINK apartir de uma posição do Monomero
/// </summary>
/// <param name="selectNode">Node selecionado</param>
/// <param name="posInit">Retorna por referência o ponto inicial do Kink</param>
/// <param name="posEnd">Retorna por referência o ponto final do Kink</param>
/// <returns>Retorno TRUE se o Kink existir.</returns>
internal static bool ExistKick(int selectNode, ref Structs.BasicStructs.Point posInit, ref Structs.BasicStructs.Point posEnd)
{
try
{
//Ponto Vizinho anterior do Monomero sorteado
posInit = new Structs.BasicStructs.Point()
{
x = GCPS.chain.r[selectNode - 1].x, y = GCPS.chain.r[selectNode - 1].y, z = GCPS.chain.r[selectNode - 1].z
};
//Ponto Vizinho posterior do Monomero sorteado
posEnd = new Structs.BasicStructs.Point()
{
x = GCPS.chain.r[selectNode + 1].x, y = GCPS.chain.r[selectNode + 1].y, z = GCPS.chain.r[selectNode + 1].z
};
//return (GridProteinFolding.Core.Internal.Maths4Simulation.Maths4Simulation.DistanceBetweenPointsWithSqrt(posInit, posEnd) == 1.4142135623730951);
return(Classification.Kink.IsKink(selectNode));
}
catch (System.ArgumentOutOfRangeException ex)
{
GICO.WriteLine(ex);
return(false);
}
}
/// <summary>
/// Verifica se existe movimento de Kink
/// </summary>
/// <param name="index">Monomero atual</param>
/// <returns>True de existir</returns>
public static bool IsKink(int index)
{
try
{
int len = (GCPS.chain.r.Count) - 1;
int idx01 = index - 1;
int idx02 = index + 1;
if ((idx01 < 0 || idx02 < 0) || (idx01 > len || idx02 > len))
{
return(false);
}
Structs.BasicStructs.Point previousPos = GCPS.chain.r[idx01];
Structs.BasicStructs.Point actualPos = GCPS.chain.r[index];
Structs.BasicStructs.Point posteriorPos = GCPS.chain.r[idx02];
return(Kink.ExistKick(previousPos, actualPos, posteriorPos));
}
catch (System.ArgumentOutOfRangeException ex)
{
new GridProteinFolding.Middle.Helpers.LoggingHelpers.Log().ArgumentOutOfRangeException(ex, Types.ErrorLevel.Warning, true);
return(false);
}
}
/// <summary>
/// Verifica se o CrankShaft ocorre ao centro a esquerda
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public static bool IsCrankShaftLeftCenter(int index)
{
try
{
int len = (GCPS.chain.r.Count) - 1;
int idx01 = index - 1;
int idx02 = index + 1;
int idx03 = index + 2;
if ((idx01 < 0 || idx02 < 0 || idx03 < 0) || (idx01 > len || idx02 > len || idx03 > len))
{
return(false);
}
Structs.BasicStructs.Point actualMinusOne = GCPS.chain.r[idx01];
Structs.BasicStructs.Point actual = GCPS.chain.r[index];
Structs.BasicStructs.Point actualMoreOne = GCPS.chain.r[idx02];
Structs.BasicStructs.Point actualMoreTwo = GCPS.chain.r[idx03];
bool testOne = (Maths4Simulation.DistanceBetweenPoints(actual, actualMoreTwo) == Consts.valueTwo);
bool testTwo = (Maths4Simulation.DistanceBetweenPoints(actualMinusOne, actualMoreOne) == Consts.valueTwo);
bool testThree = (Maths4Simulation.DistanceBetweenPoints(actualMinusOne, actualMoreTwo) == Consts.valueOne);
return(testOne && testTwo && testThree);
}
catch (System.ArgumentOutOfRangeException ex)
{
new GridProteinFolding.Middle.Helpers.LoggingHelpers.Log().ArgumentOutOfRangeException(ex, Types.ErrorLevel.Warning, true);
return(false);
}
}
/// <summary>
/// Executa o Movimento de KINK, respeitando a regra para o mesmo.
/// 1- Os Monomenos tem que estar no mesmo plano
/// 2- Tem que percenter somente a um mesmo plano
/// Para comprir, assim é definido pela distancia entre dois pontos.
/// </summary>
/// <returns></returns>
public bool Do()
{
int x_ = GCPS.chain.r[GCPS.chain.selectNode - 1].x + GCPS.chain.r[GCPS.chain.selectNode + 1].x - GCPS.chain.r[GCPS.chain.selectNode].x;
int y_ = GCPS.chain.r[GCPS.chain.selectNode - 1].y + GCPS.chain.r[GCPS.chain.selectNode + 1].y - GCPS.chain.r[GCPS.chain.selectNode].y;
int z_ = GCPS.chain.r[GCPS.chain.selectNode - 1].z + GCPS.chain.r[GCPS.chain.selectNode + 1].z - GCPS.chain.r[GCPS.chain.selectNode].z;
//copia dos dados do monomero para movimento
Structs.BasicStructs.Point temp = new Structs.BasicStructs.Point()
{
x = x_, y = y_, z = z_
};
temp.e = new List <TypeE>();
temp.e.AddRange(GCPS.chain.r[GCPS.chain.selectNode].e);
if (TryMove(ref temp))
{
GCPS.tempChain.r[GCPS.chain.selectNode] = temp;
GCPS.tempChain.contMoves.kinkAccept++;
GCPS.tempChain.typeOfLattice = BasicEnums.Lattices.Kink;
return(true);
}
else
{
GCPS.chain.contMoves.kinkReject++;
return(false);
}
}
/// <summary>
/// Classifica o Monomero por Monomero, incluindo E se Ends, K se Kink e C se CrankShaft na propriedade classificationMotion do Point
/// </summary>
public static void PreClassificationOfMotion()
{
for (int i = 0; i < GCPS.chain.r.Count; i++)
{
Structs.BasicStructs.Point actualPoint = GCPS.chain.r[i];
//Verifica se é END
actualPoint.classificationMotion.ends = Ends.IsEnds(i);
//Verifica se é KINK
actualPoint.classificationMotion.kink = Kink.IsKink(i);
//Verifica se é CRANKSHAFT
actualPoint.classificationMotion.crankShaft__R0 = CrankShaft.IsCrankShaftLeft(i);
actualPoint.classificationMotion.crankShaft__R1 = CrankShaft.IsCrankShaftLeftCenter(i);
actualPoint.classificationMotion.crankShaft__R2 = CrankShaft.IsCrankShaftRightCenter(i);
actualPoint.classificationMotion.crankShaft__R3 = CrankShaft.IsCrankShaftRight(i);
//stretched
actualPoint.classificationMotion.stretched = Straight.IsStraight(i);
GCPS.chain.r[i] = actualPoint;
}
}
/// <summary>
/// Save a classificação do tipo de Movimento possível
/// </summary>
public static void SaveClassificationOfMotion(string file)
{
string dir = IO.Directory.SubDirClassificationOfMotion;
string pathFile = dir + @"\" + file + Consts.extensionOfFile;
ExtendedStreamWriter sw = new ExtendedStreamWriter(Config.Crypt);
sw.CreateText(pathFile, Config.CurrentGuid);
for (int i = 0; i < GCPS.chain.r.Count; i++)
{
Structs.BasicStructs.Point temp = GCPS.chain.r[i];
sw.Write("{0}\t", i);
sw.Write("{0}", temp.classificationMotion.ends == true ? "E " : string.Empty);
sw.Write("{0}", temp.classificationMotion.stretched == true ? "S " : string.Empty);
sw.Write("{0}", temp.classificationMotion.kink == true ? "T " : string.Empty);
sw.Write("{0}", temp.classificationMotion.crankShaft__R0 == true ? "CR0 " : string.Empty);
sw.Write("{0}", temp.classificationMotion.crankShaft__R1 == true ? "CR1 " : string.Empty);
sw.Write("{0}", temp.classificationMotion.crankShaft__R2 == true ? "CR2 " : string.Empty);
sw.Write("{0}", temp.classificationMotion.crankShaft__R3 == true ? "CR3 " : string.Empty);
sw.WriteLine();
}
sw.Flush();
sw.Close();
}
/// <summary>
/// Verificação da geração de DeadEnd
/// </summary>
/// <param name="tempCoord">Ponto temporário</param>
/// <param name="lastValed">Último monomero válido</param>
/// <returns>True se existir</returns>
public static bool GenCountDeadEndPoints(Point tempCoord, int lastValed)
{
Structs.BasicStructs.Point changeValue = GCPS.chain.r[lastValed];
changeValue.deadEnd++;
changeValue.deadEndPoints = tempCoord.x.ToString() + "," + tempCoord.y.ToString() + "," + tempCoord.z.ToString();
GCPS.chain.r[lastValed] = changeValue;
return(GCPS.chain.r[lastValed].deadEnd == Consts.deadEnd);
}
/// <summary>
/// Aplica o movimento no eixo Z
/// </summary>
/// <param name="temp">Monomero selecionado para a ação</param>
internal static void MoveZ(ref Structs.BasicStructs.Point temp)
{
if (Randomic.randu < 0.5)
{
temp.z--;
}
else
{
temp.z++;
}
}
/// <summary>
/// Funcao que check a existencia de primeiro vizinho
/// </summary>
/// <param name="tempCoord">Ponto temporário</param>
/// <returns>True se ocorrer</returns>
public static bool FirstNeighbor(Structs.BasicStructs.Point tempCoord)
{
for (int i = 0; i < GCPS.chain.r.Count - 2; i++)
{
if (Maths4Simulation.DistanceBetweenPoints(GCPS.chain.r[i], tempCoord) == Consts.valueOne)
{
return(true);
}
}
return(false);
}
internal static bool TryFisrtContact(ref Structs.BasicStructs.Point temp)
{
//Verifica se existe contato de primeiro grau
Structs.BasicStructs.Point tempFor;
for (int i = GCPS.chain.r.Count + 2; i < GCPS.chain.r.Count; i++)
{
tempFor = GCPS.chain.r[i];
if (Maths4Simulation.DistanceBetweenPointsWithSqrt(tempFor, temp) == Consts.mapContact)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Verifica se o movimento é valido. A rotina corre todos os Nomomeros da lista e comparação todos os seus Eixos com o Movimento temporário, o qual ainda não foi confirmado.
/// </summary>
/// <param name="temp">Monomero o qual será aplicado o movimento</param>
/// <returns>Return TRUE se o movimento ocorreu</returns>
internal static bool TryMove(ref Structs.BasicStructs.Point temp)
{
//Hint: foreach http://msdn.microsoft.com/en-us/library/ttw7t8t6(VS.80).aspx
//foreach (Structs.Point checkMonomers in GCPS.chain.r)
for (int i = 0; i < GCPS.chain.r.Count; i++)
{
Structs.BasicStructs.Point checkMonomers = GCPS.chain.r[i];
//se o Monomero da lista for igual ao temporário, então a ação é cancelada
if ((checkMonomers.x == temp.x) && (checkMonomers.y == temp.y) && (checkMonomers.z == temp.z))
{
return(false);
}
}
return(true);
}
public static bool CheckOverRidWithConstains()
{
int lenghtArray = GCPS.chain.r.Count;
for (int i = 0; i < (lenghtArray - 2); i++)
{
Structs.BasicStructs.Point[] temp01 = new Structs.BasicStructs.Point[lenghtArray - i];
GCPS.chain.r.CopyTo(i, temp01, 0, (lenghtArray - i));
Structs.BasicStructs.Point[] temp02 = new Structs.BasicStructs.Point[lenghtArray - i - 1];
GCPS.chain.r.CopyTo((i + 1), temp02, 0, (lenghtArray - i - 1));
if (temp01.Any(temp02.Contains))
{
return(true);
}
}
return(false);
}
internal static bool TryMovePeerDPP(ref Structs.BasicStructs.Point temp, Structs.BasicStructs.Point checkMonomers)
{
return(Maths4Simulation.DistanceBetweenPointsWithSqrt((Structs.BasicStructs.Point)temp, (Structs.BasicStructs.Point)checkMonomers) == Consts.valueOne);
}
/// <summary>
/// Retorna a distância entre dois pontos
/// </summary>
/// <param name="p1">Ponto 1</param>
/// <param name="p2">Ponto 2</param>
/// <returns>Valor double do cálculo</returns>
public static double DistanceBetweenPoints(Structs.BasicStructs.Point p1, Structs.BasicStructs.Point p2)
{
//a distancia e igual a raiz quadrada da soma dos quadrados dos catetos formados pelos pontos
return(Math.Pow((p2.x - p1.x), 2) + Math.Pow((p2.y - p1.y), 2) + Math.Pow((p2.z - p1.z), 2));
}
/// <summary>
/// Testa a existencia de um KINK apartir de uma posição do Monomero (usando produto escalar)
/// </summary>
/// <param name="previousPos">Referência o ponto anterior ao atual</param>
/// <param name="actualPos">Referência o ponto atual</param>
/// <param name="posteriorPos">Referência o ponto posterior ao atual</param>
/// <returns>Retorno TRUE se o Kink existir.</returns>
private static bool ExistKick(Structs.BasicStructs.Point previousPos, Structs.BasicStructs.Point actualPos, Structs.BasicStructs.Point posteriorPos)
{
return(ScalarProduct.Calc(previousPos, actualPos, posteriorPos) == 0);
}
/// <summary>
/// Este Metodo executa o movimento de End.
/// </summary>
/// <returns>Return TRUE se o movimento ocorreu</returns>
public bool Do()
{
Structs.BasicStructs.Point r1;
Structs.BasicStructs.Point r2;
if (GCPS.chain.selectNode == 0)
{
//r1 = Members.monomero.r[Members.monomero.selectNode];
//r2 = Members.monomero.r[Members.monomero.selectNode + 1];
//copia dos dados do monomero para movimento
r1 = new Structs.BasicStructs.Point()
{
x = GCPS.chain.r[GCPS.chain.selectNode].x,
y = GCPS.chain.r[GCPS.chain.selectNode].y,
z = GCPS.chain.r[GCPS.chain.selectNode].z
};
r1.e = new List <TypeE>();
r1.e.AddRange(GCPS.chain.r[GCPS.chain.selectNode].e);
//copia dos dados do monomero para movimento
r2 = new Structs.BasicStructs.Point()
{
x = GCPS.chain.r[GCPS.chain.selectNode + 1].x,
y = GCPS.chain.r[GCPS.chain.selectNode + 1].y,
z = GCPS.chain.r[GCPS.chain.selectNode + 1].z
};
r2.e = new List <TypeE>();
r2.e.AddRange(GCPS.chain.r[GCPS.chain.selectNode + 1].e);
}
else
{
//r1 = Members.monomero.r[Members.monomero.selectNode];
//r2 = Members.monomero.r[Members.monomero.selectNode - 1];
//copia dos dados do monomero para movimento
r1 = new Structs.BasicStructs.Point()
{
x = GCPS.chain.r[GCPS.chain.selectNode].x,
y = GCPS.chain.r[GCPS.chain.selectNode].y,
z = GCPS.chain.r[GCPS.chain.selectNode].z
};
r1.e = new List <TypeE>();
r1.e.AddRange(GCPS.chain.r[GCPS.chain.selectNode].e);
//copia dos dados do monomero para movimento
r2 = new Structs.BasicStructs.Point()
{
x = GCPS.chain.r[GCPS.chain.selectNode - 1].x,
y = GCPS.chain.r[GCPS.chain.selectNode - 1].y,
z = GCPS.chain.r[GCPS.chain.selectNode - 1].z
};
r2.e = new List <TypeE>();
r2.e.AddRange(GCPS.chain.r[GCPS.chain.selectNode - 1].e);
}
//Vetor p, como sendo a difereça entre os vetores posuicao do residuo "2" e do residuo "1", isto é: p=r1-r1
Structs.BasicStructs.Point p = new Structs.BasicStructs.Point()
{
x = r2.x - r1.x,
y = r2.y - r1.y,
z = r2.z - r1.z
};
//Definicao dos dois vetores v e w
Structs.BasicStructs.Point v;
Structs.BasicStructs.Point w;
//cria as 3 possibilidades para v e w
if (p.x != 0)
{
v = new Structs.BasicStructs.Point()
{
x = 0, y = p.x, z = 0
};
w = new Structs.BasicStructs.Point()
{
x = 0, y = 0, z = p.x
};
}
else if (p.y != 0)
{
v = new Structs.BasicStructs.Point()
{
x = 0, y = 0, z = p.y
};
w = new Structs.BasicStructs.Point()
{
x = p.y, y = 0, z = 0
};
}
else //if (p.z != 0)
{
v = new Structs.BasicStructs.Point()
{
x = p.z, y = 0, z = 0
};
w = new Structs.BasicStructs.Point()
{
x = 0, y = p.z, z = 0
};
}
//Sorteio do movimento para 4 possibilidades (de 0 à 3)
Randomic.Random();
int i = (int)(Randomic.randu * 4);
end type = end.none;
switch (i)
{
case 0:
//Primeira possibilidade: r1=r2+vi
r1.x = r2.x + v.x;
r1.y = r2.y + v.y;
r1.z = r2.z + v.z;
type = end.one;
break;
case 1:
//Segunda possibilidade: r1=r2-vi
r1.x = r2.x - v.x;
r1.y = r2.y - v.y;
r1.z = r2.z - v.z;
type = end.two;
break;
case 2:
//Terceira possibilidade: r1=r2+wi
r1.x = r2.x + w.x;
r1.y = r2.y + w.y;
r1.z = r2.z + w.z;
type = end.three;
break;
case 3:
//Quarta possibilidade: r1=r2-wi
r1.x = r2.x - w.x;
r1.y = r2.y - w.y;
r1.z = r2.z - w.z;
type = end.four;
break;
default:
new GridProteinFolding.Middle.Helpers.LoggingHelpers.Log().Exception(new System.Exception("Error ends.."), Types.ErrorLevel.Warning);
break;
}
//GICO.WriteLine("{0} {1} {2}", r1.x, r1.y, r1.z);
//Verifica a aceitação do movimento
if (TryMove(ref r1)) // && TryMovePeerDPP(ref pointSorted, (Structs.Point)Members.monomero.r[neighborNode]))
{
GCPS.tempChain.r[GCPS.chain.selectNode] = r1;
GCPS.tempChain.contMoves.endsAccept++;
switch (type)
{
case end.one:
GCPS.tempChain.contMoves.moveSetEnd.endAccept_1++;
break;
case end.two:
GCPS.tempChain.contMoves.moveSetEnd.endAccept_2++;
break;
case end.three:
GCPS.tempChain.contMoves.moveSetEnd.endAccept_3++;
break;
case end.four:
GCPS.tempChain.contMoves.moveSetEnd.endAccept_4++;
break;
}
GCPS.tempChain.typeOfLattice = BasicEnums.Lattices.End;
return(true);
}
else
{
GCPS.chain.contMoves.endsReject++;
switch (type)
{
case end.one:
GCPS.chain.contMoves.moveSetEnd.endReject_1++;
break;
case end.two:
GCPS.chain.contMoves.moveSetEnd.endReject_2++;
break;
case end.three:
GCPS.chain.contMoves.moveSetEnd.endReject_3++;
break;
case end.four:
GCPS.chain.contMoves.moveSetEnd.endReject_4++;
break;
}
return(false);
}
}
/// <summary>
/// Testa a existencia de um KINK apartir de uma posição do Monomero
/// </summary>
/// <param name="previousPos">Referência o ponto anterior ao atual</param>
/// <param name="posteriorPos">Referência o ponto posterior ao atual</param>
/// <returns>Retorno TRUE se o Kink existir.</returns>
protected static bool ExistKick(Structs.BasicStructs.Point previousPos, Structs.BasicStructs.Point posteriorPos)
{
return(Maths4Simulation.DistanceBetweenPoints(previousPos, posteriorPos) == Consts.valueTwo);
}
/// <summary>
/// Executa teste de validação de MONOMERO seleciona é um crankShaft
/// </summary>
/// <returns></returns>
public bool Do()
{
int internalSelectNode = GCPS.chain.selectNode;
//Movimento de crankShaft é sempre em função de R1
//Abaixo efetuaremos o ajustes do Ri
if (GCPS.chain.r[internalSelectNode].classificationMotion.crankShaft__R0)
{
internalSelectNode++;
}
else if (GCPS.chain.r[internalSelectNode].classificationMotion.crankShaft__R2)
{
internalSelectNode--;
}
else if (GCPS.chain.r[internalSelectNode].classificationMotion.crankShaft__R3)
{
internalSelectNode = internalSelectNode - 2;
}
// |P = |v3 - |v0
int Px = GCPS.chain.r[internalSelectNode + 1].x - GCPS.chain.r[internalSelectNode - 1].x;
int Py = GCPS.chain.r[internalSelectNode + 1].y - GCPS.chain.r[internalSelectNode - 1].y;
int Pz = GCPS.chain.r[internalSelectNode + 1].z - GCPS.chain.r[internalSelectNode - 1].z;
// |Q = |v1 - |v0
int Qx = GCPS.chain.r[internalSelectNode].x - GCPS.chain.r[internalSelectNode - 1].x;
int Qy = GCPS.chain.r[internalSelectNode].y - GCPS.chain.r[internalSelectNode - 1].y;
int Qz = GCPS.chain.r[internalSelectNode].z - GCPS.chain.r[internalSelectNode - 1].z;
//O vetor |V é perpendicular a |P e a |Q simultaneamente
int Vx = (Py * Qz) - (Qy * Pz); //em direção de X
int Vy = (Pz * Qx) - (Qz * Px); //em direção de Y
int Vz = (Px * Qy) - (Qx * Py); //em direção de Z
//Tres possibilidades de movimento (3)
int R_x = 0;
int R_y = 0;
int R_z = 0;
int R_x_1 = 0;
int R_y_1 = 0;
int R_z_1 = 0;
//Sorteio do movimento
Randomic.Random();
int sort = (int)(Randomic.randu * 3);
crankshaft type = crankshaft.none;
switch (sort)
{
case 0:
//Primeira possibilidade (1)
//onde |r´i = |ri-1 + |V
R_x = GCPS.chain.r[internalSelectNode - 1].x + Vx;
R_y = GCPS.chain.r[internalSelectNode - 1].y + Vy;
R_z = GCPS.chain.r[internalSelectNode - 1].z + Vz;
//onde |r´i+1 = |ri+2 + |V
R_x_1 = GCPS.chain.r[internalSelectNode + 2].x + Vx;
R_y_1 = GCPS.chain.r[internalSelectNode + 2].y + Vy;
R_z_1 = GCPS.chain.r[internalSelectNode + 2].z + Vz;
type = crankshaft.one;
break;
case 1:
//Segunda possibilidade (2)
//onde |r´i = |ri-1 - |V
R_x = GCPS.chain.r[internalSelectNode - 1].x - Vx;
R_y = GCPS.chain.r[internalSelectNode - 1].y - Vy;
R_z = GCPS.chain.r[internalSelectNode - 1].z - Vz;
//onde |r´i+1 = |ri+2 - |V
R_x_1 = GCPS.chain.r[internalSelectNode + 2].x - Vx;
R_y_1 = GCPS.chain.r[internalSelectNode + 2].y - Vy;
R_z_1 = GCPS.chain.r[internalSelectNode + 2].z - Vz;
type = crankshaft.two;
break;
case 2:
//Terceira possibilidade (3)
//onde |r´i = |ri-1 - |Q
R_x = GCPS.chain.r[internalSelectNode - 1].x - Qx;
R_y = GCPS.chain.r[internalSelectNode - 1].y - Qy;
R_z = GCPS.chain.r[internalSelectNode - 1].z - Qz;
//onde |r´i+1 = |ri+2 - |Q
R_x_1 = GCPS.chain.r[internalSelectNode + 2].x - Qx;
R_y_1 = GCPS.chain.r[internalSelectNode + 2].y - Qy;
R_z_1 = GCPS.chain.r[internalSelectNode + 2].z - Qz;
type = crankshaft.three;
break;
default:
new GridProteinFolding.Middle.Helpers.LoggingHelpers.Log().Exception(new System.Exception("Error Sort"), Types.ErrorLevel.Warning);
break;
}
Structs.BasicStructs.Point temp01 = new Structs.BasicStructs.Point()
{
x = R_x, y = R_y, z = R_z
};
temp01.e = new List <TypeE>();
temp01.e.AddRange(GCPS.chain.r[internalSelectNode].e);
Structs.BasicStructs.Point temp02 = new Structs.BasicStructs.Point()
{
x = R_x_1, y = R_y_1, z = R_z_1
};
temp02.e = new List <TypeE>();
temp02.e.AddRange(GCPS.chain.r[internalSelectNode + 1].e);
if (TryMove(ref temp01) && TryMove(ref temp02))
{
GCPS.tempChain.r[internalSelectNode] = temp01;
GCPS.tempChain.r[internalSelectNode + 1] = temp02;
GCPS.tempChain.contMoves.crankshaftAccept++;
switch (type)
{
case crankshaft.one:
GCPS.tempChain.contMoves.moveSetCrankshaft.crankshaftAccept_1++;
break;
case crankshaft.two:
GCPS.tempChain.contMoves.moveSetCrankshaft.crankshaftAccept_2++;
break;
case crankshaft.three:
GCPS.tempChain.contMoves.moveSetCrankshaft.crankshaftAccept_3++;
break;
}
GCPS.tempChain.typeOfLattice = BasicEnums.Lattices.Crank;
return(true);
}
else
{
GCPS.chain.contMoves.crankshaftReject++;
switch (type)
{
case crankshaft.one:
GCPS.chain.contMoves.moveSetCrankshaft.crankshaftReject_1++;
break;
case crankshaft.two:
GCPS.chain.contMoves.moveSetCrankshaft.crankshaftReject_2++;
break;
case crankshaft.three:
GCPS.chain.contMoves.moveSetCrankshaft.crankshaftReject_3++;
break;
}
return(false);
}
}
