示例#1
0
 public static void SaveData(ref LatticeMoves objLatticeMoves)
 {
     //Salva snapshot calculo da "variação de energia" e salva em arquivo o valor de "U"
     CalculatingEnergy.SaveValueOfDebugFile();
     //Salva o movimento da cadeia
     Recorder.RecMov(objLatticeMoves, AppConfigClient.Param.dataToProcess.splitFileEvery);
 }
        public static void RecTrajectoryFileCalcSpinningRay_MIN(LatticeMoves objLatticeMoves)
        {
            long mCStep                   = GCPS.McSteps;
            long totalMoviments           = GCPS.chain.contMoves.SumOfAcceptedAndRejectedMovement;
            long numberOfMovementsApplied = GCPS.chain.contMoves.NumberOfMovementsApplied;

            objLatticeMoves.RecTrajectoryFileCalcSpinningRay_MIN(mCStep, totalMoviments, numberOfMovementsApplied, GCPS.chain.r, Config.Param.dataToProcess.Guid);
        }
        public static void RecTrajectoryFile(LatticeMoves objLatticeMoves, Int32 splitFileEvery, bool firstStep = false)
        {
            long mCStep                   = GCPS.McSteps;
            long totalMoviments           = GCPS.chain.contMoves.SumOfAcceptedAndRejectedMovement;
            long numberOfMovementsApplied = GCPS.chain.contMoves.NumberOfMovementsApplied;

            objLatticeMoves.RecTrajectoryFile(mCStep, totalMoviments, numberOfMovementsApplied, GCPS.chain.r, Config.Param.dataToProcess.Guid, splitFileEvery, firstStep);
        }
示例#4
0
 private static void Snapshot(ref LatticeMoves objLatticeMoves)
 {
     //Valida processo de Snapshot
     if (AppConfigClient.Param.dataToProcess.recPathEvery == 1 || AppConfigClient.Param.dataToProcess.recPathEvery == 0)
     {
         SaveData(ref objLatticeMoves);
     }
     else
     {
         if (StateControl.recPathEvery < (AppConfigClient.Param.dataToProcess.recPathEvery - 1))
         {
             StateControl.recPathEvery++;
         }
         else
         {
             SaveData(ref objLatticeMoves);
             StateControl.recPathEvery = 0;
         }
     }
 }
        public static void RecTrajectoryFileSandBox(LatticeMoves objLatticeMoves)
        {
            long mCStep = GCPS.McSteps;

            objLatticeMoves.RecTrajectoryFileSandBox(mCStep, GCPS.chain.r);
        }
        public static void RecTrajectoryFileCalcSpinningRay(Guid guid, long maxInterations, LatticeMoves objLatticeMoves)
        {
            PrinterMessages.PrintBootomHeader(guid, maxInterations);

            //Calculo do ultimo raio de giração
            double calcSpinningRay = RecWriteCalcSpinningRay();

            if (calcSpinningRay > 2.1412 && calcSpinningRay < 2.1413)
            {
                RecTrajectoryFileCalcSpinningRay_MIN(objLatticeMoves);
            }
        }
 public static void RecMov(LatticeMoves objLatticeMoves, Int32 splitFileEvery)
 {
     RecTrajectoryFile(objLatticeMoves, splitFileEvery);
 }
示例#8
0
 public static void Snapshot(ref LatticeMoves objLatticeMoves)
 {
     SaveData(ref objLatticeMoves);
 }
示例#9
0
        /// <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);
        }
示例#10
0
        /// <summary>
        /// Aplica TEMPO de passo em MONTE CARLO!
        /// </summary>
        public static bool Run()
        {
            LatticeMoves objLatticeMoves = new LatticeMoves();

            InitVariables.Do();

            #region Criação Movimentação MoveSet

            StateControl.condStop       = (GCPS.chain.r.Count + 1) * 2;
            StateControl.maxInterations = AppConfigClient.Param.dataToProcess.maxInterations; //numero maximo de tentativas
            StateControl.recPathEvery   = 0;

            PrinterMessages.PrintHeader(AppConfigClient.CurrentGuid, StateControl.maxInterations);//, StateControl.condStop);

            //Salva a primeira configuração do monomero
            Recorder.RecTrajectoryFile(objLatticeMoves, AppConfigClient.Param.dataToProcess.splitFileEvery, true);

            //Salva snapshot calculo da "variação de energia" e salva em arquivo o valor de "U"
            CalculatingEnergy.existFileForSaveDebug = false;
            CalculatingEnergy.SaveValueOfDebugFile();


            int maxValConTop = 0;

            DateTime startDateTime = DateTime.Now;
            Console.WriteLine("Start: {0}", startDateTime.ToString());

            for (GCPS.mcStepsLoop01 = 0; GCPS.mcStepsLoop01 < StateControl.maxInterations; GCPS.mcStepsLoop01++)
            {
                //PRINT %
                PrinterMessages.PrintPercentCompleted(AppConfigClient.CurrentGuid);

                for (GCPS.mcStepsLoop02 = 0; GCPS.mcStepsLoop02 < GCPS.mcStepsLoop02_LIMITE; GCPS.mcStepsLoop02++) //loop externo de 5 passos
                {
                    for (GCPS.mcStepsLoop03 = 0; GCPS.mcStepsLoop03 < GCPS.chain.r.Count; GCPS.mcStepsLoop03++)    //loop para tamanha da cadeia
                    {
                        GCPS.chain.CopyToTempMonomero();

                        //Sorteiro o residuo para a tentativa de movimento
                        LatticeMoves.SortMoviment();

                        //var occuredMotion armazena o boleano da ocorrência de movimentos dos três (3) tipos abaixo:
                        bool occuredMotion = objLatticeMoves.LatticeTryModeSetCrankshaft();
                        if (!occuredMotion)
                        {
                            occuredMotion = objLatticeMoves.LatticeTryModeSetEnds();
                            if (!occuredMotion)
                            {
                                occuredMotion = objLatticeMoves.LatticeTryModeSetKink();
                                if (!occuredMotion)
                                {
                                    GCPS.chain.contMoves.othersReject++;
                                }
                            }
                        }

                        //Verifica se ocorreu um movimento na cadeia temporária
                        if (occuredMotion)
                        {
                            //Excluir valores energia (e) anterior se existentes ao node
                            //CalculatingEnergy.DelEnergy(GCPS.tempMonomero.selectNode);
                            //Rotina executa: Processa calculo da "variação de energia" e salva em arquivo o valor de "U"  Reclassifica a cadeia TEMPORARIA
                            //GCPS.tempMonomero.NeighborsUpdatePeerPoint(GCPS.tempMonomero.selectNode);


                            //Reclassifica TODA A CADEIA
                            GCPS.tempChain.NeighborsUpdateAll();


                            #region
                            //Condição de Teste:
                            //(1) deltaE <=0 -> "Aceita a nova configuração"
                            //(2) deltaE >0 -> Então
                            //      - Calcula e^-deltaE*beta (calcE)
                            //      - Gerar um número randôico (r) entre 0 e 1
                            //      Se r<=calcE então "Aceita a nova configuração"
                            //          Senão "Rejeita a nova configuração"
                            #endregion
                            //Efetua calcula das varívais do meio ambiente (deltaE, lastR e lastTransitionProbability, RG, DPP e etc)
                            Structs.Environment.CalculateEnvironment();

                            if (AcceptMove())
                            {
                                //Salva classificaca da cadeia
                                GCPS.tempChain.NeighborsSave(GCPS.chain.isem, ref GCPS.chain.numberNeighborTopological);

                                //Aceita o movimento
                                GCPS.chain.AcceptMotion();

                                if (GCPS.chain.ECount() != (GCPS.chain.TotalNeighborTopological() / 2))
                                {
                                    new GridProteinFolding.Middle.Helpers.LoggingHelpers.Log().ErrorNeighborTopological(new ErrorNeighborTopological("GCPS.chain.ECount() != (GCPS.chain.TotalNeighborTopological() / 2"), Types.ErrorLevel.Warning);
                                }

                                //Snapshot(ref objLatticeMoves);
                                //REC
                                if (GCPS.chain.numberNeighborTopological >= (GCPS.chain.r.Count - 1))
                                {
                                    FoundData(startDateTime);
                                    Snapshot(ref objLatticeMoves);
                                }

                                //Condição de parada
                                if (GCPS.chain.numberNeighborTopological >= (GCPS.chain.r.Count))
                                {
                                    FoundData(startDateTime);

                                    Snapshot(ref objLatticeMoves);

                                    if (Structs.Environment.rg == 1.41)
                                    {
                                        break;
                                    }
                                }
                                else
                                {
                                    if (maxValConTop < GCPS.chain.numberNeighborTopological)
                                    {
                                        maxValConTop = GCPS.chain.numberNeighborTopological;

                                        FoundData(startDateTime);
                                    }
                                }
                            }

                            GCPS.chain.interationEnergy = string.Empty;
                            GCPS.chain.typeOfLattice    = BasicEnums.Lattices.None;

                            //Se movimento ocorreu, é necessário pré qualificar novamente toda a cadeia
                            ClassificationMotion.PreClassificationOfMotion();

                            if (StateControl.condStop == GCPS.chain.TotalNeighborTopological())
                            {
                                break;
                            }
                        }
                        GCPS.McStepsDo();
                    }
                }
            }

            //Salva o movimento da cadeia
            Recorder.RecTrajectoryFileCalcSpinningRay(AppConfigClient.CurrentGuid, StateControl.maxInterations, objLatticeMoves);

            GICO.WriteLine(AppConfigClient.CurrentGuid, String.Format("MCSteps: {0}", GCPS.McSteps));
            //Check Parse do ultimo arquivo valido
            if (!LatticeMoves.Parse())
            {
                new GridProteinFolding.Middle.Helpers.LoggingHelpers.Log().ErroParseMoves(new ErroParseMovesException("ErroParseMoves"), Types.ErrorLevel.None);
            }

            //MoveSet de saída do movimento do ultimo arquivo valido
            Recorder.RecTrajectoryFile(objLatticeMoves, AppConfigClient.Param.dataToProcess.splitFileEvery);

            //MoveSet (RESULT)
            objLatticeMoves.RecMoveSet(AppConfigClient.CurrentGuid, SimulationResults + Directory.FileExtension);

            objLatticeMoves.Disposed();
            objLatticeMoves = null;

            #endregion

            return(true);
        }
示例#11
0
        /// <summary>
        /// Aplica TEMPO de passo em MONTE CARLO!
        /// </summary>
        public static bool Run()
        {
            LatticeMoves objLatticeMoves = new LatticeMoves();

            InitVariables.Do();

            #region Criação Movimentação MoveSet

            //StateControl.condStop = (GCPS.chain.r.Count + 1) * 2;
            StateControl.maxInterations = AppConfigClient.Param.dataToProcess.maxInterations; //numero maximo de tentativas
            StateControl.recPathEvery   = 0;

            PrinterMessages.PrintHeader(AppConfigClient.CurrentGuid, StateControl.maxInterations);//, StateControl.condStop);

            //Salva a primeira configuração do monomero
            Recorder.RecTrajectoryFile(objLatticeMoves, AppConfigClient.Param.dataToProcess.splitFileEvery, true);

            //Salva snapshot calculo da "variação de energia" e salva em arquivo o valor de "U"
            CalculatingEnergy.existFileForSaveDebug = false;
            CalculatingEnergy.SaveValueOfDebugFile();

            //int maxValConTop = 0;
            bool stoped = false;

            DateTime startDateTime = DateTime.Now;
            Console.WriteLine("Start: {0}", startDateTime.ToString());

            while (!stoped)
            {
                GCPS.chain.CopyToTempMonomero();

                //Sorteiro o residuo para a tentativa de movimento
                LatticeMoves.SortMoviment();

                //var occuredMotion armazena o boleano da ocorrência de movimentos dos três (3) tipos abaixo:
                bool occuredMotion = objLatticeMoves.LatticeTryModeSetCrankshaft();
                if (!occuredMotion)
                {
                    occuredMotion = objLatticeMoves.LatticeTryModeSetEnds();
                    if (!occuredMotion)
                    {
                        occuredMotion = objLatticeMoves.LatticeTryModeSetKink();
                        if (!occuredMotion)
                        {
                            GCPS.chain.contMoves.othersReject++;
                        }
                    }
                }

                //Verifica se ocorreu um movimento na cadeia temporária
                if (occuredMotion)
                {
                    //Reclassifica TODA A CADEIA
                    GCPS.tempChain.NeighborsUpdateAll();

                    //Efetua calcula das varívais do meio ambiente (deltaE, lastR e lastTransitionProbability, RG, DPP e etc)
                    Structs.Environment.CalculateEnvironment();

                    if (AcceptMove())
                    {
                        //Salva classificaca da cadeia
                        GCPS.tempChain.NeighborsSave(GCPS.chain.isem, ref GCPS.chain.numberNeighborTopological);

                        //Aceita o movimento
                        GCPS.chain.AcceptMotion();

                        if (GCPS.chain.ECount() != (GCPS.chain.TotalNeighborTopological() / 2))
                        {
                            new GridProteinFolding.Middle.Helpers.LoggingHelpers.Log().ErrorNeighborTopological(new ErrorNeighborTopological("GCPS.chain.ECount() != (GCPS.chain.TotalNeighborTopological() / 2"), Types.ErrorLevel.Warning);
                        }

                        //Condição de parada
                        if (GCPS.chain.numberNeighborTopological >= (GCPS.chain.r.Count))
                        {
                            FoundData(startDateTime);
                            Snapshot(ref objLatticeMoves);

                            if (CheckStruct())
                            {
                                stoped = true;
                            }
                        }
                    }

                    GCPS.chain.interationEnergy = string.Empty;
                    GCPS.chain.typeOfLattice    = BasicEnums.Lattices.None;

                    //Se movimento ocorreu, é necessário pré qualificar novamente toda a cadeia
                    ClassificationMotion.PreClassificationOfMotion();
                }
                GCPS.McStepsDo();
            }

            //Salva o movimento da cadeia
            Recorder.RecTrajectoryFileCalcSpinningRay(AppConfigClient.CurrentGuid, StateControl.maxInterations, objLatticeMoves);

            GICO.WriteLine(AppConfigClient.CurrentGuid, String.Format("MCSteps: {0}", GCPS.McSteps));
            //Check Parse do ultimo arquivo valido
            if (!LatticeMoves.Parse())
            {
                new GridProteinFolding.Middle.Helpers.LoggingHelpers.Log().ErroParseMoves(new ErroParseMovesException("ErroParseMoves"), Types.ErrorLevel.None);
            }

            //MoveSet de saída do movimento do ultimo arquivo valido
            Recorder.RecTrajectoryFile(objLatticeMoves, AppConfigClient.Param.dataToProcess.splitFileEvery);

            //MoveSet (RESULT)
            objLatticeMoves.RecMoveSet(AppConfigClient.CurrentGuid, SimulationResults + Directory.FileExtension);



            //Compara estruturas com as TARGETS
            //ComparerTargets(GCPS.chain.r);
            #endregion

            //MoveSet de saída do movimento para SANDBOX
            Recorder.RecTrajectoryFileSandBox(objLatticeMoves);

            objLatticeMoves.Disposed();
            objLatticeMoves = null;

            return(true);
        }