---

main.cpp

Go to the documentation of this file.

// main.cpp : Defines the entry point for the console application.
//

#ifdef _WINDOWS
//#include "stdafx.h"
//#include <crtdbg.h>
#endif

// debugging only
//#define _CRT_DEBUG_MAP_ALLOC
#include <stdlib.h>
//#include <crtdbg.h>

#include <time.h>
#include <fstream>
#include <iostream>
#include <string.h>
//#include "PC12EGFNGFMinimizableDirector.h"
//#include "PC12RapMinusMinimizableDirector.h"
//#include "OneGeneInhibitoryNetworkMinimizableDirector.h"
//#include "AlternateOneGeneInhibitoryNetworkMinimizableDirector.h"
#include "ZeroTAnnealMinimizer.h"
#include "PositiveDefiniteLevenbergMarquardtMinimizer.h"
#include "ParameterReader.h"
#include "GnuPlotterSimulatedAnnealingObserver.h"
#include "LogParameterFilter.h"
#include "SquareRootParameterFilter.h"
#include "IdentityParameterFilter.h"
#include "MixedReactionNetwork.h"
//#include "OneGeneInhibitoryAveragingDirector.h"
#include "BasicQuenchMinimizer.h"
#include "RobustLevenbergMarquardtMinimizer.h"
#include "ImprovedLevenbergMarquardtMinimizer.h"
#include "ScaleInvariantMarquardtMinimizer.h"
#include "VariableStepsizeAnnealMinimizer.h"
#include "ConjugateGradientMinimizer.h"
#include "ConjugateGradientObserver.h"
//#include "PC12EGFNGFRunDirector.h"
//#include "PC12AlternateMinimizableDirector.h"
#include "ParameterRandomizer.h"
#include "ExampleNetworkMinimizableDirector.h"
#include "StochasticSensitivityAnalysis.h"
#include "GnuPlotterCostObserver.h"
#include "GnuPlotterParameterScatterPlot.h"
#include "GnuPlotterResidualScatterPlot.h"
#include "CommaStrategyOne.h"
#include "ClonalCommaES.h"
//#include "OneGeneEnsembleRunDirector.h"
//#include "OneGeneEnsembleDirector.h"
//#include "PC12EGFNGFEnsembleDirector.h"
//#include "PC12AlternateEnsembleDirector.h"
//#include "PC12RapMinusEnsembleDirector.h"
//#include "CoupledOneGeneNetworksMinimizableDirector.h"
//#include "CoupledPC12NetworksMinimizableDirector.h"
//#include "EGFRTraffickingCoupledMinimizableDirector.h"
//#include "EGFRTraffickingIdealCellMinimizableDirector.h"
//#include "EGFRTraffickingRunDirector.h"
//#include "EGFRTraffickingEnsembleDirector.h"
#include "LowDimensionalCostFunctionMapper.h"
//#include "PC12ParameterTranslator.h"
#include "AcceptanceRatioFreeEnergyEstimator.h"
//#include "LaubLoomisDictyNetworkMinimizableDirector.h"
//#include "LaubLoomisDictyNetworkEnsembleDirector.h"
//#include "MartielGoldbeterDictyNetworkMinimizableDirector.h"
#include "ForcesObserver.h"
//#include "OneGeneInhibitoryNetworkRunDirector.h"
//#include "CombinatorialNetworksSloppyMinimizableDirector.h"
#include "LeastSquaresObserver.h"
#include "PeriodicQuenchMinimizer.h"
#include "NelderMeadSimplexMinimizer.h"

#include "TranslationModelMinimizable.h"
#include "LocateInputFileDirectory.h"

main(int argc, char* argv[])
{
 int i; 
        // MICROSOFT DEBUGGING STUFF
        //_crtBreakAlloc = 55;  // Breaks at memory allocation failure no. ?
        // global variable
        //_CrtSetBreakAlloc(22584);

        //int tmpFlag = _CRTDBG_REPORT_FLAG;
        //tmpFlag |= _CRTDBG_DELAY_FREE_MEM_DF;
        //tmpFlag |= _CRTDBG_ALLOC_MEM_DF; // use any checking at all.
        //tmpFlag |= _CRTDBG_LEAK_CHECK_DF; // at end of program.
        //tmpFlag |= _CRTDBG_CHECK_ALWAYS_DF; // end of program
        //tmpFlag &= ~_CRTDBG_DELAY_FREE_MEM_DF; // turn it off

        //_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_CHECK_ALWAYS_DF);
        //_CrtMemState s1,s2,s3;
        //_CrtMemCheckpoint( &s1 );

        //ReactionNetwork *rN = new CEGFRTraffickingNetwork();
        //rN->DumpPetriNetDotFile("PetriPC12.dot");
        //rN->DumpTeXForm("traffic.tex");
        //delete rN;
        

        
        //CRunDirector *rD = new COneGeneInhibitoryNetworkRunDirector();
        //CRunDirector *rD = new COneGeneInhibitoryAveragingDirector();
        //CRunDirector *rD = new CPC12EGFNGFRunDirector();
        //CRunDirector *rD = new CEGFRTraffickingRunDirector();
        //CEnsembleCombinationDirector *rD = new COneGeneEnsembleDirector(500);
        //CEnsembleCombinationDirector *rD = new CPC12EGFNGFEnsembleDirector(704);
        //CEnsembleCombinationDirector *rD = new CPC12AlternateEnsembleDirector(50);
        //CEnsembleCombinationDirector *rD = new CLaubLoomisDictyNetworkEnsembleDirector(60);
        //CEnsembleCombinationDirector *rD = new CPC12RapMinusEnsembleDirector(320);
        //CEnsembleCombinationDirector *rD = new CEGFRTraffickingEnsembleDirector(200);

        /*
        cin.get();
        rD->Execute();
        cin.get();
        delete rD;
        */
        
        /*
        NetworkMinimizableDirector *pS1 = new CPC12AlternateMinimizableDirector();
        NetworkMinimizableDirector *pS0 = new PC12EGFNGFMinimizableDirector();
        CParameterTranslator *pT = new CPC12ParameterTranslator();
        CAcceptanceRatioFreeEnergyEstimator *pDeltaF = new CAcceptanceRatioFreeEnergyEstimator(pS0,686,pS1,1000,pT);
        pDeltaF->LoadEnsemble("ensemble0.par","ensemble1.par");
        pDeltaF->ComputeHistograms();

        delete pS0;
        delete pS1;
        delete pT;
        delete pDeltaF;
        */

        // define an uber-minimizable
        //NetworkMinimizableDirector *nM = new CPC12AlternateMinimizableDirector();
        
        //NetworkMinimizableDirector *nM = new PC12EGFNGFMinimizableDirector();

        //NetworkMinimizableDirector *nM = new CPC12RapMinusMinimizableDirector();
        
        //NetworkMinimizableDirector *nM = new CCoupledPC12NetworksMinimizableDirector(0.01,0.0);

        //NetworkMinimizableDirector *nM = new COneGeneInhibitoryNetworkMinimizableDirector();
        
        //NetworkMinimizableDirector *nM = new CAlternateOneGeneInhibitoryNetworkMinimizableDirector();

        //NetworkMinimizableDirector *nM = new CExampleNetworkMinimizableDirector();
        
        //NetworkMinimizableDirector *nM = new CCoupledOneGeneNetworksMinimizableDirector(0.01,0.0);
        
        //NetworkMinimizableDirector *nM = new CEGFRTraffickingIdealCellMinimizableDirector();

        //NetworkMinimizableDirector *nM = new CEGFRTraffickingCoupledMinimizableDirector(1.0,0.0);
        
        //NetworkMinimizableDirector *nM = new CEGFRTraffickingNIH3T3MinimizableDirector();

        //NetworkMinimizableDirector *nM = new CEGFRTraffickingCHOMinimizableDirector();
 
        //NetworkMinimizableDirector *nM = new CLaubLoomisDictyNetworkMinimizableDirector();
        
        //NetworkMinimizableDirector *nM = new CMartielGoldbeterDictyNetworkMinimizableDirector();

// Find directory for input files: assumed base directory contains folddata.dat
        LocateInputFileDirectory locate("folddata.dat");
        NLLSMinimizable *nM = new TranslationModelMinimizable(&locate, locate.Get("folddata.dat"),12);

        /*
        // read in two sets of parameters
        ParameterReader *pR1 = new ParameterReader("min2_cg_woPI3K.par");
        double *p1 = new double[nM->GetNParameters()];
        for(int i = 0; i < nM->GetNParameters(); i++)
        {
                p1[i] = pR1->ReadParameter();
        }
        delete pR1;
        ParameterReader *pR2 = new ParameterReader("min3_cg_woPI3K.par");
        double *p2 = new double[nM->GetNParameters()];
        for(i = 0; i < nM->GetNParameters(); i++)
        {
                p2[i] = pR2->ReadParameter();
        }
        delete pR2;
        ParameterReader *pR3 = new ParameterReader("min4_cg_woPI3K.par");
        double *p3 = new double[nM->GetNParameters()];
        for(i = 0; i < nM->GetNParameters(); i++)
        {
                p3[i] = pR3->ReadParameter();
        }
        delete pR3;
        
        // create the mapper and filter
        CLowDimensionalCostFunctionMapper *pMap = new CLowDimensionalCostFunctionMapper();
        CParameterFilter *pFilter = new CLogParameterFilter();
        // do the mapping
        pMap->Map(nM,pFilter,p1,p2,p3,-1,1,-1,1,961);

        delete pMap;
        delete pFilter;
        delete nM;
        delete [] p1;
        delete [] p2;
        delete [] p3;
        */
        /*
        // use default parameters
        double *parameters = new double[nM->GetNParameters()];
        for(int i = 0; i < nM->GetNParameters(); i++)
        {
                parameters[i] = nM->GetParameter(i);
        }
        */
        
        // read parameters from previous optimization pass
        ParameterReader *pReader = new ParameterReader(locate.Get("translation_default.par"));

        double *parameters = new double[nM->GetNParameters()];
        cout << "Total number of parameters is " << nM->GetNParameters() << endl;
        for(i = 0; i < nM->GetNParameters(); i++)
        {
                parameters[i] = pReader->ReadParameter();
        }
        delete pReader;
        
        /*
        // randomize parameters
        CParameterRandomizer *pR = new CParameterRandomizer(776157);
        pR->Randomize(parameters,nM->GetNParameters(),0.5,1);
        delete pR;
        */
        
        //cin.get();
        //clock_t start,finish;
        //start = clock();
        //double cost = nM->ObjectiveFunction(parameters);
        //cout << "Ground state cost is " << cost << endl;
        //finish = clock();
        //for(i = 0; i < nM->GetNExperiments(); i++)
        //{
        //      cout << "Steps: " << nM->GetMover(i)->GetTotalStepsTaken() << endl;
        //}
        //cout << "Clock Duration: " << (double)(finish - start)/CLOCKS_PER_SEC;
        //cin.get();
        

        /*
        // STEPSIZE TESTER - FOR USE WITH STOCHASTIC SENSITIVITY
        // evaluate the objective function at the minimum to determine what size step
        // to give to fixed stepsize mover
        double cost = nM->ObjectiveFunction(parameters);
        cout << "Cost of parameter set is " << cost << endl;
        for(int nEx = 0; nEx < nM->GetNExperiments(); nEx++)
        {
                cout << "Experiment " << nEx << ":" << endl;
                cout << "\tSmallest stepsize was " << nM->GetMover(nEx)->GetMinStepSize() << endl;
                cout << "\tLargest stepsize was " << nM->GetMover(nEx)->GetMaxStepSize() << endl;
                cout << "\tTotal number of steps was " << nM->GetMover(nEx)->GetTotalStepsTaken() << endl;
        }
        // just a dummy so I don't have to keep commenting out delete statement at bottom
        Minimizer *minimizer = new CBasicQuenchMinimizer(1,10,1.0,1);
        */
        /*
        CParameterFilter *pFilter = new CLogParameterFilter();
        CStochasticSensitivityAnalysis *minimizer = new CStochasticSensitivityAnalysis(false,false,0,9801,pFilter,1.0e-6,1.0);
        cout << "Performing Stochastic Sensitivity Analysis" << endl;
        
        minimizer->DoAnalysis(parameters,nM);
        
        cout << "RW Variance : " << minimizer->GetRWValue() << endl;
        delete pFilter;
        */
        /*
        cout << "(mu/rho,lambda)-ES One Selected" << endl;
        CParameterFilter *filter = new CLogParameterFilter();
        Minimizer *minimizer = new CCommaStrategyOne(filter,1.0,15,2,50,100,887);
        double cost = minimizer->Minimize(parameters,nM);
        cout << "Average cost of final population " << cost << endl;
        delete filter;
        */
        /*
        cout << "(mu,lambda)-ES Selected" << endl;
        CParameterFilter *filter = new CLogParameterFilter();
        Minimizer *minimizer = new CClonalCommaES(filter,0.0,15,100,1109);
        double cost = minimizer->Minimize(parameters,nM);
        cout << "Average cost of final population " << cost << endl;
        delete filter;
        */
        
        
        // BE CAREFUL WITH THE ERROR TOLERANCE, PARTICULARLY IF YOU USE A LOW ORDER
        // INTEGRATOR
        /*
        cout << "Nelder-Mead Simplex Selected" << endl;
        CParameterFilter *filter = new CLogParameterFilter();
        Minimizer *minimizer = new CNelderMeadSimplexMinimizer(filter,1000,2.0);
        double cost = minimizer->Minimize(parameters,nM);
        cout << "Final cost of " << cost << endl;
        delete filter;
        */
        /*
        cout << "Levenberg-Marquardt Selected" << endl;
        CParameterFilter *filter = new CLogParameterFilter();
        Minimizer *minimizer = new CImprovedLevenbergMarquardtMinimizer(filter,false,1.0e-06,false,1.0e-08,true,1.0e-06,true,1.0e-06,1,1.0e-06);
        Observer *LSObs = new CLeastSquaresObserver();
        minimizer->Attach(LSObs);
        double cost = minimizer->Minimize(parameters,nM);
        cout << "Final cost of " << cost << endl;
        minimizer->Detach(LSObs);
        delete filter;
        delete LSObs;
        */
        
        /*
        cout << "Scale-Invariant Levenberg-Marquardt Selected" << endl;
        CParameterFilter *filter = new CLogParameterFilter();
        Minimizer *minimizer = new CScaleInvariantMarquardtMinimizer(filter,false,1.0e-2,true,1.0e-08,true,1.0e-06,true,1.0e-06,1000,1.0e-06);
        double cost = minimizer->Minimize(parameters,nM);
        cout << "Final cost of " << cost << endl;
        delete filter;
        */

        cout << "Conjugate Gradient Selected" << endl;
        CParameterFilter *filter = new CLogParameterFilter();
        Minimizer *minimizer = new CConjugateGradientMinimizer(false,filter,500,1.0e-06);
        //Observer *CGObs = new CConjugateGradientObserver();
        //minimizer->Attach(CGObs);
        double cost = minimizer->Minimize(parameters,nM);
        //minimizer->Detach(CGObs);
        //delete CGObs;
        delete filter;
        
        /*
        cout << "Basic Quench Selected" << endl;
        int nEquilibrationSteps = 25;
        double stepScale = 0.0;
        CParameterFilter *filter = new CLogParameterFilter();
        Minimizer *minimizer = new CBasicQuenchMinimizer(nEquilibrationSteps,10,stepScale,99449,filter);
        double cost = minimizer->Minimize(parameters,nM);
        */
        
        /*
        cout << "Variable Stepsize SA Selected" << endl;
        CParameterFilter *filter = new CLogParameterFilter();
        Minimizer *minimizer = new CVariableStepsizeAnnealMinimizer(4040440,filter,10,0.7,0.15,10);
        //GnuPlotter *plotter = new GnuPlotterSimulatedAnnealingObserver();
        //minimizer->Attach(plotter);
        double cost = minimizer->Minimize(parameters,nM);
        //minimizer->Detach(plotter);
        //delete plotter;
        delete filter;
        */
        /*
        cout << "Periodic Quench Selected" << endl;
        CParameterFilter *filter = new CLogParameterFilter();
        Minimizer *minimizer = new CPeriodicQuenchMinimizer(5587,filter,true,10,200,1.0e-02,10,0.5,2.0);
        double cost = minimizer->Minimize(parameters,nM);
        delete filter;
        */
        
        cout << "Best cost for this minimization is " << cost << endl;
        // write the best parameters to a file and stdout
        fstream *pfbest = new fstream("translation_cg.par",ios::out);
        *pfbest << "##################################################################" << endl;
        *pfbest << "# BEST PARAMETERS" << endl;
        *pfbest << "# COST : " << cost << endl;
        *pfbest << "##################################################################" << endl;
        for(i = 0; i < nM->GetNParameters(); i++)
        {
           *pfbest << parameters[i] << endl;
        }
        delete pfbest;
        
        
        delete minimizer;
        delete [] parameters;           
        delete nM;
        
        //_CrtDumpMemoryLeaks();
        
        //_CrtMemCheckpoint( &s2 );
        
        /*
        if ( _CrtMemDifference( &s3, &s1, &s2) ) 
                _CrtMemDumpStatistics( &s3 );
        */

        return 0;
}

---