---

BasicQuenchMinimizer.cpp

Go to the documentation of this file.

// BasicQuenchMinimizer.cpp: implementation of the CBasicQuenchMinimizer class.
//

#include "BasicQuenchMinimizer.h"

// Construction/Destruction

CBasicQuenchMinimizer::CBasicQuenchMinimizer(int nTrialSteps,int nCycles, double initialStepScale, int seed, CParameterFilter *pFilter)
:CSimulatedAnnealingStrategy(seed,pFilter)
{
        m_iNCycles = nCycles;
        m_iNTrialSteps = nTrialSteps;
        m_dInitialStepScale = initialStepScale;
}

CBasicQuenchMinimizer::~CBasicQuenchMinimizer()
{

}

void CBasicQuenchMinimizer::InitializeTemperature(Minimizable *minimizable)
{
        // Temperature in this algorithm just records iterations
        m_dTemperature = 1.0;
        m_dStepScale = m_dInitialStepScale;
}

void CBasicQuenchMinimizer::GenerateMove()
{
        // take a uniform step between -stepScale and +stepScale
        m_pFilter->ForwardTransformation(m_pdCurrentParameters,nParameters);
        for(int i = 0; i < nParameters; i++)
        {
                m_pdTrialParameters[i] = m_pdCurrentParameters[i] + m_dStepScale*(2*m_pRNG->uniform() - 1.0);
        }
        // back transform both sets
        m_pFilter->BackwardTransformation(m_pdCurrentParameters,nParameters);
        m_pFilter->BackwardTransformation(m_pdTrialParameters,nParameters);
}

bool CBasicQuenchMinimizer::AcceptMove(double Eold, double Enew)
{
        double deltaE = Enew - Eold;

        if(deltaE < 0)
        {
                return true;
        }

        return false;
}

void CBasicQuenchMinimizer::Cool()
{
        m_dTemperature += 1.0;
        cout << "Iteration number " << m_dTemperature << ", ";
        // adjust the step scale to keep the acceptance ratio between 0.5 and 0.8
        if(m_dAcceptanceRatio < 0.5)
        {
                // severely reduce the stepsize in order to accept some moves
                if(m_dAcceptanceRatio == 0.0)
                {
                        m_dStepScale = __min(m_dStepScale/2.0,m_dInitialStepScale/2.0);
                        cout << "Scale cut in half." << endl;
                }
                else
                {

                        // decrease stepsize
                        m_dStepScale = 0.85*m_dStepScale;
                        cout << "Scale decreased." << endl;
                }
        }
        else if(m_dAcceptanceRatio > 0.8)
        {
                m_dStepScale = (1/0.85)*m_dStepScale;
                cout << "Scale increased." << endl;
        }
        
        // write the best (temporary) parameters to a file and stdout
        fstream *pfbest = new fstream("optimized.par",ios::out);
        *pfbest << "##################################################################" << endl;
        *pfbest << "# BEST PARAMETERS (PARTIAL)" << endl;
        *pfbest << "##################################################################" << endl;
        for(int i = 0; i < nParameters; i++)
        {
                *pfbest << m_pdCurrentParameters[i] << endl;
        }
        delete pfbest;
}

bool CBasicQuenchMinimizer::Terminate()
{
        if(m_dTemperature > m_iNCycles)
        {
                return true;
        }

        return false;
}

bool CBasicQuenchMinimizer::Equilibrated()
{
        if(m_iTrialCount > m_iNTrialSteps)
        {
                return true;
        }
        
        return false;
}

---