clustersim.cpp

Go to the documentation of this file.

/***************************************************************************************************
*****           Copyright (C) 2005  John Schneiderman <JohnMS@member.fsf.org>                  *****
*****                                                                                          *****
*****           This program is free software; you can redistribute it and/or modify           *****
*****           it under the terms of the GNU General Public License as published by           *****
*****           the Free Software Foundation; either version 2 of the License, or              *****
*****           (at your option) any later version.                                            *****
*****                                                                                          *****
*****           This program is distributed in the hope that it will be useful,                *****
*****           but WITHOUT ANY WARRANTY; without even the implied warranty of                 *****
*****           MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                  *****
*****           GNU General Public License for more details.                                   *****
*****                                                                                          *****
*****           You should have received a copy of the GNU General Public License              *****
*****           along with this program; if not, write to the Free Software                    *****
*****           Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA     *****
***************************************************************************************************/
#ifdef HAVE_CONFIG_H
    #include <config.h>
#endif

#include <iostream>
using std::cout;
using std::cerr;
using std::cin;
using std::endl;
#include <fstream>
using std::ofstream;

// User interaction classes
#include "menu.h"
#include "configurationdatabase.h"
//Known clusters
#include "fcclattice.h"
//Known simulations
#include "mdsimulation.h"
#include "mcsimulation.h"
#include "mdljsimulation.h"
#include "mcljsimulation.h"

string createCluster(Cluster &cluster, const ConfigurationDatabase &conf);
string selectSimulation(Cluster &cluster, string prevName, const ConfigurationDatabase &conf);
void interactiveRun(ConfigurationDatabase &conf, Cluster &cluster);
void nonInteractiveRun(ConfigurationDatabase &conf, ConfigurationDatabase runSetup, Cluster &cluster);

int main(int argc, char *argv[])
{
    //Parse command line arguments
    string confFile="clustersim.conf";
    bool interactive=true;
    string nonInteractiveFilename;

    if (argc > 1)
        for (int i=1; i < argc; i++)
            if (strcmp(argv[i], "-v") == 0)
            {
                cout << "ClusterSim version " << VERSION << ", Copyright (C) 2005 John Schneiderman" << endl;
                return EXIT_SUCCESS;
            }
            else if (strcmp(argv[i], "-c") == 0)
                confFile=argv[++i];
            else if (strcmp(argv[i], "-n") == 0)
            {
                nonInteractiveFilename=argv[++i];
                interactive=false;
            }
            else if (strcmp(argv[i], "-h") == 0)
            {
                cout << "usage: clustersim [-(v)ersion] [-(h)elp] [-(c)onf file] [-(n)on-interactive file]" << endl;
                return EXIT_SUCCESS;
            }
            else
            {
                cout << argv[i] << " is not an option." << endl;
                cout << "usage: clustersim [-(v)ersion] [-(h)elp] [-(c)onf file] [-(n)on-interactive file]" << endl;
                return EXIT_SUCCESS;
            }

    //Display notice
    cout << "ClusterSim version " << VERSION << ", Copyright (C) 2005, 2006 John Schneiderman" << endl;
    cout << "ClusterSim comes with ABSOLUTELY NO WARRANTY; This is free software," << endl;
    cout << "and you are welcome to redistribute it under certain conditions; see" << endl;
    cout << "the COPYING file for details, or the Free Software Foundation's GPL." << endl << endl;
    try
    {
        ConfigurationDatabase conf(confFile);
        Cluster cluster;

        if (interactive)
            interactiveRun(conf, cluster);
        else
            nonInteractiveRun(conf, ConfigurationDatabase(nonInteractiveFilename), cluster);
        return EXIT_SUCCESS;
    }
    catch (const char *message)
    {
        cerr << message << endl;
        return EXIT_FAILURE;
    }
    catch (string message)
    {
        cerr << message << endl;
        return EXIT_FAILURE;
    }
    catch (...)
    {
        cerr << "Unknown error occured." << endl;
        return EXIT_FAILURE;
    }
}

string createCluster(Cluster &cluster, const ConfigurationDatabase &conf)
{
    Menu clusterMenu("Cluster Creations", "Enter type of lattice to create: ");
    string baseName="";
    int baseSize, menuSelected;
    double reducedDensity;
    FCC_Lattice fcc;

    baseSize=conf.intValue("clusters", "baseSize");
    reducedDensity=conf.doubleValue("clusters", "reducedDensity");
    clusterMenu.addMenuItem("FCC Lattice");
    while(true)
    {
        clusterMenu.draw();
        menuSelected = clusterMenu.selectMenuItem();
        if (menuSelected == clusterMenu.menuItem("FCC Lattice"))
        {
            cout << "Enter base size, or 0 for default (" << baseSize <<  "): ";
            cin >> baseSize;
            if (baseSize <= 0)
                baseSize=conf.intValue("clusters", "baseSize");
            cout << "Enter the reduced density, or 0 for default (" << reducedDensity <<  "): ";
            cin >> reducedDensity;
            if (reducedDensity <= 0)
                reducedDensity=conf.doubleValue("clusters", "reducedDensity");
            fcc.createLattice(baseSize, reducedDensity, cluster);
            cout << "Enter base name to save the Cluster to: ";
            cin >> baseName;
            cluster.write(baseName);
            return baseName;
        }
        else if (menuSelected == Menu::MENU_EXIT)
            return "";
    }
}

string selectSimulation(Cluster &cluster, string prevName, const ConfigurationDatabase &conf)
{
    Menu simMenu("Simulation Options", "Enter simulation type to run: ");
    BaseSimulation *sim;
    MC_Simulation *mcSim;
    string currentName;
    int steps, printInterval, menuSelected;
    double changeInSteps=0.0;

    simMenu.addMenuItem("Molecular Dynamic Lenard-Jones Simulation");
    simMenu.addMenuItem("Monte Carlo Lenard-Jones Simulation");
    // Make sure our cluster is good to go.
    if (cluster.size() < 2)
    {
        simMenu.setFeedback("Cluster is not set up!");
        return prevName;
    }
    // Lets rock
    while(true)
    {
        // Process menu and user's interaction
        simMenu.draw();
        menuSelected = simMenu.selectMenuItem();
        if (menuSelected == simMenu.menuItem("Molecular Dynamic Lenard-Jones Simulation"))
        {
            sim = new MDLJ_Simulation(conf);
            break;
        }
        else if (menuSelected == simMenu.menuItem("Monte Carlo Lenard-Jones Simulation"))
        {
            double temp=conf.doubleValue("sims", "temperature");

            mcSim = new MCLJ_Simulation(conf);
            cout << "Enter the temperature for this system, 0 for default (" << temp <<  "): ";
            cin >> temp;
            if (temp == 0)
                temp=conf.doubleValue("sims", "temperature");
            mcSim->setTemperature(temp);
            sim = mcSim;
            break;
        }
        else if (menuSelected == Menu::MENU_EXIT)
            return prevName;
    }
    // Are we ready to start a simulation?
    if (sim != NULL)
    {
        // Get default values
        steps=conf.intValue("sims", "steps");
        printInterval=conf.intValue("sims", "printInterval");
        changeInSteps=conf.doubleValue("sims", "changeInSteps");
        // Lets see if the user wants to change any of those values
        cout << "Enter the number of steps for this run, 0 for default (" << steps <<  "): ";
        cin >> steps;
        if (steps <= 0)
            steps=conf.intValue("sims", "steps");
        cout << "Enter the interval between steps, 0 for default (" << changeInSteps <<  "): ";
        cin >> changeInSteps;
        if (changeInSteps <= 0)
            changeInSteps=conf.doubleValue("sims", "changeInSteps");
        cout << "Enter the print interval, 0 for default (" << printInterval <<  "): ";
        cin >> printInterval;
        if (printInterval <= 0)
            printInterval=conf.intValue("sims", "printInterval");
        cout << "Enter the new run name (i.e. run001): ";
        cin >> currentName;
        // Time to set and run those values
        sim->setRunSteps(steps);
        sim->setPrintInterval(printInterval);
        sim->setChangeInStep(changeInSteps);
        sim->run(cluster, currentName, prevName);
        delete sim;
        return currentName;
    }
    else
    {
        return prevName;
    }
}

void interactiveRun(ConfigurationDatabase &conf, Cluster &cluster)
{
    Menu mainMenu("ClusterSim Programme", "Please enter selection: ");
    string currentRunName="";
    int menuSelected;

    //Create and Process menu
    mainMenu.addMenuItem("Create a Cluster");
    mainMenu.addMenuItem("Run a simulation");
    mainMenu.addMenuItem("Load a previous simulation run");
    mainMenu.addMenuItem("Save the current simulation run");
    mainMenu.addMenuItem("Save settings as defaults");
    while(true)
    {
        mainMenu.draw();
        menuSelected = mainMenu.selectMenuItem();
        if (menuSelected == mainMenu.menuItem("Create a Cluster"))
            currentRunName=createCluster(cluster, conf);
        else if (menuSelected == mainMenu.menuItem("Run a simulation"))
            currentRunName=selectSimulation(cluster, currentRunName, conf);
        else if (menuSelected == mainMenu.menuItem("Load a previous simulation run"))
        {
            cout << "Enter base name of the run to load: ";
            cin >> currentRunName;
            try
            {
                cluster.read(currentRunName);
                mainMenu.setFeedback("Simulation data successfully read.");
            }
            catch (const char *errMessage)
            {
                mainMenu.setFeedback("File " + currentRunName + " not found.");
                cluster.clear();
            }
        }
        else if (menuSelected == mainMenu.menuItem("Save the current simulation run"))
        {
            if (cluster.size() > 1)
                try
                {
                    cluster.write(currentRunName);
                    mainMenu.setFeedback("Simulation data successfully written.");
                }
                catch (const char *errMessage)
                {
                    mainMenu.setFeedback("File " + currentRunName + " failed to save.");
                }
            else
                mainMenu.setFeedback("Cluster is empty!");
        }
        else if (menuSelected == mainMenu.menuItem("Save settings as defaults"))
        {
            string path;

            cout << "Enter path to save the configuration file, or - to return:";
            cin >> path;
            if (path != "-")
            {
                path += "/clustersim.conf";
                ofstream out(path.c_str());
                out << conf;
                mainMenu.setFeedback("Saved Configuration file:" + path);
            }
        }
        else if (menuSelected == Menu::MENU_EXIT)
            break;
    }
}

void nonInteractiveRun(ConfigurationDatabase &conf, ConfigurationDatabase runSetup, Cluster &cluster)
{
    vector<string> headers=runSetup.headers();
    string simType;
    BaseSimulation *sim;
    MD_Simulation *mdSim;
    MC_Simulation *mcSim;

    for (int i=0; i < headers.size(); i++)
    {
        cout << "Starting simulation " << headers[i] << " ..." << endl;
        try
        {
            cluster.read(runSetup.stringValue(headers[i], "previousName"));
        }
        catch (const char *errMessage)
        {
            cerr << errMessage << endl;
            return;
        }
        simType=runSetup.stringValue(headers[i], "simType");
        if (simType == "mdlj")
        {
            try
            {
                mdSim = new MDLJ_Simulation(conf);
                sim = mdSim;
            }
            catch (string message)
            {
                cerr << message << endl;
                return;
            }
        }
        else
        {
            try
            {
                mcSim = new MCLJ_Simulation(conf);
                mcSim->setTemperature(runSetup.doubleValue(headers[i], "temperature"));
                sim = mcSim;
            }
            catch (string message)
            {
                cerr << message << endl;
                return;
            }
        }
        sim->setRunSteps(runSetup.intValue(headers[i], "steps"));
        sim->setChangeInStep(runSetup.doubleValue(headers[i], "changeInSteps"));
        sim->setPrintInterval(runSetup.intValue(headers[i], "printInterval"));
        sim->run(cluster, runSetup.stringValue(headers[i], "currentName"), runSetup.stringValue(headers[i], "previousName"));
        cluster.write(runSetup.stringValue(headers[i], "currentName"));
        cout << "Finished simulation " << headers[i] << "." << endl;
        cluster.clear();
        if (sim != NULL)
            delete sim;
    }
}

---