---

AcceptanceRatioFreeEnergyEstimator.cpp

Go to the documentation of this file.

// AcceptanceRatioFreeEnergyEstimator.cpp: implementation of the CAcceptanceRatioFreeEnergyEstimator class.
//

#include "AcceptanceRatioFreeEnergyEstimator.h"

// Construction/Destruction

CAcceptanceRatioFreeEnergyEstimator::CAcceptanceRatioFreeEnergyEstimator()
{

}

CAcceptanceRatioFreeEnergyEstimator::CAcceptanceRatioFreeEnergyEstimator(Minimizable *pS0, int n0, Minimizable *pS1, int n1, CParameterTranslator *pTrans)
{
        m_pSystem0 = pS0;
        m_pSystem1 = pS1;
        m_iN0 = n0;
        m_iN1 = n1;
        m_pTranslator = pTrans;
}


CAcceptanceRatioFreeEnergyEstimator::~CAcceptanceRatioFreeEnergyEstimator()
{
        int i;
        for(i = 0; i < m_vpdEnsemble0.size(); i++)
        {
                delete [] m_vpdEnsemble0[i];
        }
        for(i = 0; i < m_vpdEnsemble1.size(); i++)
        {
                delete [] m_vpdEnsemble1[i];
        }

        m_vdHistogram0.clear();
        m_vdHistogram1.clear();

}

void CAcceptanceRatioFreeEnergyEstimator::ComputeHistograms()
{
        int i,count;
        int nP0 = m_pSystem0->GetNParameters();
        int nP1 = m_pSystem1->GetNParameters();
        double *temp0 = new double[nP0];
        double *temp1 = new double[nP1];

        
        // get the h0 histogram - i.e., run both minimizables with the zero parameters
        for(i = 0; i < m_iN0; i++)
        {
                // zero system takes its own parameters freely
                double cost0in0 = m_pSystem0->ObjectiveFunction(m_vpdEnsemble0[i]);
                // transform the zero parameters to run in the one system
                m_pTranslator->ZeroToOne(m_vpdEnsemble0[i],nP0,temp1,nP1);
                double cost0in1 = m_pSystem1->ObjectiveFunction(temp1);
                // now get the difference
                m_vdHistogram0.push_back(cost0in1 - cost0in0);
                // write a message to the screen
                cout << "Set " << i << " run in system 0" << endl;
        }
        /*
        // get the h1 histogram - i.e., run both minimizables with the one parameters
        for(i = 0; i < m_iN1; i++)
        {
                // one system takes its own parameters freely
                double cost1in1 = m_pSystem1->ObjectiveFunction(m_vpdEnsemble1[i]);
                // transform the one parameters to run in the zero system
                m_pTranslator->OneToZero(m_vpdEnsemble1[i],nP1,temp0,nP0);
                double cost1in0 = m_pSystem0->ObjectiveFunction(temp0);
                // now get the difference
                m_vdHistogram1.push_back(cost1in0 - cost1in1);
                // write a message to the screen
                cout << "Set " << i << " run in system 1" << endl;
        }
        */
        
        // write the histograms to files
        fstream *pfHist0 = new fstream("histogram0.par",ios::out);
        fstream *pfHist1 = new fstream("histogram1.par",ios::out);
        *pfHist0 << "##################################################################" << endl;
        *pfHist1 << "##################################################################" << endl;
        *pfHist0 << "# POTENTIAL DIFFERENCES IN 0 SYSTEM - " << m_iN0 << " SAMPLES" << endl;
        *pfHist1 << "# POTENTIAL DIFFERENCES IN 1 SYSTEM - " << m_iN1 << " SAMPLES" << endl;
        *pfHist0 << "##################################################################" << endl;
        *pfHist1 << "##################################################################" << endl;

        for(count = 0; count < m_vdHistogram0.size(); count++)
        {
                *pfHist0 << setprecision(10) << m_vdHistogram0[count] << endl;
        }
        for(count = 0; count < m_vdHistogram1.size(); count++)
        {
                *pfHist1 << setprecision(10) << m_vdHistogram1[count] << endl;
        }

        cout << "Histograms writtten." << endl;

        delete pfHist0;
        delete pfHist1;
        delete [] temp0;
        delete [] temp1;
}

void CAcceptanceRatioFreeEnergyEstimator::LoadEnsemble(std::string f0name, std::string f1name)
{
        int i,j;
        // read in two vectors of rate constants
        int nRC0 = m_pSystem0->GetNParameters();
        int nRC1 = m_pSystem1->GetNParameters();

        // two parameter readers scan the files
        ParameterReader *pEns0Reader = new ParameterReader(f0name.c_str());
        ParameterReader *pEns1Reader = new ParameterReader(f1name.c_str());

        for(i = 0; i < m_iN0; i++)
        {
                m_vpdEnsemble0.push_back(new double[nRC0]);
                for(j = 0; j < nRC0; j++)
                {
                        double parameter = pEns0Reader->ReadParameter();
                        m_vpdEnsemble0[i][j] = parameter;
                }
        }

        for(i = 0; i < m_iN1; i++)
        {
                m_vpdEnsemble1.push_back(new double[nRC1]);
                for(j = 0; j < nRC1; j++)
                {
                        double parameter = pEns1Reader->ReadParameter();
                        m_vpdEnsemble1[i][j] = parameter;
                }
        }
        
        delete pEns0Reader;
        delete pEns1Reader;

        return;
}

---