/// <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);
}
}
private static void WriteFrequencyPeerInterval(string fileName, string extFileName, BasicEnums.HistTypes histType, BasicEnums.ChainTypes chainType)
{
StringBuilder sb = Maths4Simulation.FrequencyPeerInterval(fileName + extFileName, histType, chainType);
if (sb != null)
{
string dir = IO.Directory.SubDirHistogram;
string pathFile = dir + @"\" + fileName + histogram + extFileName + Directory.FileExtension;
string[] ret = Regex.Split(sb.ToString(), "\n");
ExtendedStreamWriter sw = new ExtendedStreamWriter(Config.Crypt);
sw.CreateText(pathFile, Config.CurrentGuid);
for (int i = 0; i < ret.Count(); i++)
{
string retPrinter = ret[i];
sw.WriteLine(retPrinter);
}
sw.Flush();
sw.Close();
}
return;
}
public static double RecWriteCalcSpinningRay()
{
long sumOfAcceptedAndRejectedMovement = GCPS.chain.contMoves.SumOfAcceptedAndRejectedMovement;
string fileName = "CalcSpinningRay" + Directory.FileExtension;
double calcSpinningRay = Maths4Simulation.CalcSpinningRay();
Stream.StreamRecCalcSpinningRay(sumOfAcceptedAndRejectedMovement, calcSpinningRay, fileName);
return(calcSpinningRay);
}
/// <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);
}
/// <summary>
/// 3# regra
/// Equação: d^2 i, [j+2 -> i+2 ] = 4||2
/// A DISTÂNCIA ENTRE O MONÔMERO "i" E O MONÔMERO "i+2" , ELEVADO AO QUADRADO,
/// SÓ PODE SER IGUAL A 2, OU IGUAL A 4. QUALQUER OUTRO VALOR É UM INDICATIVO DE ERRO.
/// </summary>
/// <returns></returns>
private bool PolicyThree()
{
for (int i = 0; i < GCPS.chain.r.Count - 2; i++)
{
double tempCalc = Maths4Simulation.DistanceBetweenPointsWithSqrt(((Structs.BasicStructs.Point)GCPS.chain.r[i]), ((Structs.BasicStructs.Point)GCPS.chain.r[i + 2]));
if (!((tempCalc == Consts.valueSqrtTwo) || (tempCalc == Consts.valueSqrtFour)))
{
return(false);
}
}
return(true);
}
/// <summary>
/// 2# regra
/// Equação: d^2 i, i+1 = 1
/// A DISTÂNCIA ENTRE O MONÔMERO "i" E O MONÔMERO "i+1" , ELEVADO AO QUADRADO, SÓ PODE SER IGUAL A 1.
/// QUALQUER OUTRO VALOR RESULTANTE É INDICATIVO DE ERRO.
/// </summary>
/// <returns></returns>
private bool PolicyTwo()
{
for (int i = 0; i < GCPS.chain.r.Count - 1; i++)
{
if (!(Maths4Simulation.DistanceBetweenPoints(((Structs.BasicStructs.Point)GCPS.chain.r[i]),
((Structs.BasicStructs.Point)GCPS.chain.r[i + 1])) == Consts.valueOne))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Funcao que check a existencia de primeiro vizinho em toda a cadeia (ponto por ponto)
/// </summary>
/// <returns>True se ocorrer</returns>
public static bool FirstNeighbor()
{
for (int i = 0; i < (GCPS.chain.r.Count - 2); i++)
{
for (int k = (i + 2); k < (GCPS.chain.r.Count - 1); k++)
{
if (Maths4Simulation.DistanceBetweenPoints(GCPS.chain.r[i], GCPS.chain.r[k]) == 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);
}
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>
/// 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>
/// Essa rotina faz:
/// a) Efetua calculo raio de giração
/// b) Check sobreposição e primeiro vizinho
/// c) Check n# contrucao das cadeias
/// d) Se a cadeia for do tipo REAL, aplica movimentação da cadeia (MONTEC)
/// </summary>
/// <param name="cont"></param>
/// <param name="cadeiaIdeal"></param>
/// <param name="cadeiaReal"></param>
private bool ProcessMonomero(ref double cont, ref int cadeiaIdeal, ref int cadeiaReal, ref int cadeiaSoft, ref int cadeiaError)
{
string isemName = GCPS.initialIsem.ToString();
GCPS.chain.contMoves = new Structs.BasicStructs.MoveSetApplies();
//Efetua o calculo do Raio de giração & Distancia entre primeiro e ultimo ponto
QueueType tempQueueType = new QueueType(isemName, Maths4Simulation.CalcSpinningRay(), Maths4Simulation.CalDistanceBetweenLastPointFirst());
//Check sobreposicao e Primeiro vizinho
Protein.CheckOverRideAndFirstNeighbor(ref chainType, ref cadeiaIdeal, ref cadeiaReal, ref cadeiaSoft);
//Check na construcao das cadeias
Protein.QualificationChainTypes(ref chainType, ref tempQueueType);
//Se for CADEIA REAL SOFT aplica movimento
GCPS.chain.chainTypes = chainType;
if (GCPS.chain.chainTypes == BasicEnums.ChainTypes.Soft || GCPS.chain.chainTypes == BasicEnums.ChainTypes.Real)
{
//CHECK CONSTRUCTION
if (!LatticeMoves.Parse())
{
GCPS.chain.chainTypes = BasicEnums.ChainTypes.Error;
cadeiaError++;
cadeiaSoft--;
//GICO.WriteLine("ErroParseMoves..." + GCPS.chain.isem.ToString());
new GridProteinFolding.Middle.Helpers.LoggingHelpers.Log().ErroParseMoves(new ErroParseMovesException("ErroParseMoves..." + GCPS.chain.isem.ToString()), Types.ErrorLevel.None);
return(false);
}
else
{
//Rotina carrega e salva matriz energética
EnergeticMatrix.LoadEnergeticMatrix(AppConfigClient.Param);
EnergeticMatrix.SaveEnergeticMatrix();
//Inicializa o Monomero da simulação utilizado para movimentação (temporário)
GCPS.tempChain = new Structs.BasicStructs.TemporaryChain();
GCPS.chain.CopyToTempMonomero();
//Rotina executa: Processa calculo da "variação de energia" e salva em arquivo o valor de "U"
GCPS.tempChain.NeighborsUpdateAll();
GCPS.tempChain.NeighborsSave(GCPS.tempChain.isem, ref GCPS.chain.numberNeighborTopological);
GCPS.chain.AcceptMotion();
//classificação do Monomero quanto ao tipo de movimento possível e Salva em disco
ClassificationMotion.PreClassificationOfMotion();
#if Debug
ClassificationMotion.SaveClassificationOfMotion(GCPS.chain.isem.ToString());
#endif
//Aplica Movimentação: CHAMA MONTE CARLO
//return MoteCarlo.MonteCarloB.Run();
return(MoteCarlo.MonteCarloTsallis.Run());
}
}
return(false);
}
/// <summary>
/// 1# regra
/// Equação: 1 MENOR OU IGUAL d^2 i,j MENOR OU IGUAL (N-1)^2
/// </summary>
/// <returns></returns>
private bool PolicyOne()
{
return(Maths4Simulation.CalcSpinningRay() <= Math.Pow(GCPS.chain.r.Count - 1, 2));
}
/// <summary>
/// RG: Calcula do raio de giração (evolução)
/// </summary>
private static void RG()
{
rg = Maths4Simulation.CalcSpinningRay();
}
/// <summary>
/// RG: Calcula do raio de giração (evolução)
/// </summary>
private static void DPP()
{
dpp = Maths4Simulation.CalDistanceBetweenLastPointFirst();
}
