---

SharedParametersMinimizableDirector.cpp

Go to the documentation of this file.

// SharedParametersMinimizableDirector.cpp: implementation of the CSharedParametersMinimizableDirector class.
//

#include "SharedParametersMinimizableDirector.h"

// Construction/Destruction

CSharedParametersMinimizableDirector::CSharedParametersMinimizableDirector()
{

}

CSharedParametersMinimizableDirector::~CSharedParametersMinimizableDirector()
{
        delete m_pReplicaOne;
        delete m_pReplicaTwo;
}

int CSharedParametersMinimizableDirector::GetNParameters()
{
        int n1 = m_pReplicaOne->GetNParameters();
        int n2 = m_pReplicaTwo->GetNParameters();
        int n1intn2 = m_viIntersectOne.size();

        return n1 + n2 - n1intn2;
}

double CSharedParametersMinimizableDirector::GetParameter(int parIndex)
{
        // it's a parameter either in the intersection or 
        // unique to the first network
        int firstNP = m_pReplicaOne->GetNParameters();
        int intSize = m_viIntersectTwo.size();
        if(parIndex < firstNP)
        {
                return m_pReplicaOne->GetParameter(parIndex);
        }
        else // it's a parameter unique to the second network
        {
                return m_pReplicaTwo->GetParameter(parIndex - intSize); 
        }

}

void CSharedParametersMinimizableDirector::SetIntersectionLists()
{
                // look at all the parameters in the first minimizable/replica and determine
        // if they have counterparts in the second network.  When they are found, push
        // them onto the intersection lists
        for(int i = 0; i < m_pReplicaOne->GetReactionNetwork(0)->GetNumberOfRateConstants(); i++)
        {
                std::string firstName = m_pReplicaOne->GetReactionNetwork(0)->GetRateConstant(i)->GetName();
                for(int j = 0; j < m_pReplicaTwo->GetReactionNetwork(0)->GetNumberOfRateConstants(); j++)
                {
                        if(firstName == m_pReplicaTwo->GetReactionNetwork(0)->GetRateConstant(j)->GetName())
                        {
                                // put i on the first intersection list and j on the second

                                // intersection list
                                m_viIntersectOne.push_back(i);
                                m_viIntersectTwo.push_back(j);
                        }
                }
        }

        // before returning, if the intersection list is null print a warning
        if(m_viIntersectOne.size() == 0)
        {
                cout << "WARNING : Models have no shared parameters." << endl;
        }
}

double CSharedParametersMinimizableDirector::ComputeResiduals(double *parameters)
{
        double summedCost = 0.0;
        int nP1 = m_pReplicaOne->GetNParameters();
        int nP2 = m_pReplicaTwo->GetNParameters();
        int intSize = m_viIntersectOne.size();
        // create dummy arrays to pass appropriate sized parameter lists
        double *pOne = new double[nP1];
        double *pTwo = new double[nP2];
        // fill the arrays with the appropriate parameters
        for(int i = 0; i < intSize; i++)
        {
                pOne[i] = parameters[i];
                pTwo[i] = parameters[i];
        }
        // now fill in the parameters unique to model 1
        for(int i = intSize; i < nP1; i++)
        {
                pOne[i] = parameters[i];
        }
        // now the ones unique to model 2
        for(int i = nP1; i < nP2; i++)
        {
                pOne[intSize + (i - nP1)] = parameters[i]; 
        }
        // compute the residuals/cost from each replica
        summedCost = m_pReplicaOne->ObjectiveFunction(pOne) + m_pReplicaTwo->ObjectiveFunction(pTwo);
        
        // fill in the residuals list
        int ResOne = m_pReplicaOne->GetNResiduals();
        int ResTwo = m_pReplicaTwo->GetNResiduals();
        for(int j = 0; j < ResOne; j++)
        {
                residuals[j] = (m_pReplicaOne->GetResiduals())[j];
        }
        for(int j = ResOne; j < ResOne + ResTwo; j++)
        {
                residuals[j] = (m_pReplicaTwo->GetResiduals())[j-ResOne];
        }

        delete [] pOne;
        delete [] pTwo;

        return summedCost;
}

---