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