Mercury3DRestart.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
//based on /storage2/usr/people/sluding/MDCC/C3DshearXL30/MU0_LONG2
#ifndef MERCURY3DRESTART_H
#define MERCURY3DRESTART_H
 
#include "Mercury3D.h"
#include <sys/time.h>
#include <string.h>
 
class Mercury3DRestart : public Mercury3D
{
public:
    
    Mercury3DRestart() //: Mercury3D()
    {
        initialWallTime_ = getWallTime();
        maxWallTime_ = 10;
        clusterCommand_ = "";
    }
    
    void setClusterCommand(std::string clusterCommand)
    {
        clusterCommand_ = clusterCommand;
    }
    
    std::string getClusterCommand() const
    {
        return clusterCommand_;
    }
    
    void setMaxWallTime(Mdouble maxWallTime)
    {
        maxWallTime_ = maxWallTime;
    }
    
    Mdouble getMaxWallTime() const
    {
        return maxWallTime_;
    }
    
    Mdouble getInitialWallTime() const
    {
        return initialWallTime_;
    }
    
    bool readNextArgument(int& i, int argc, char* argv[]) override
    {
        if (!strcmp(argv[i], "-restart") || !strcmp(argv[i], "-r"))
        {
            setName(argv[i + 1]);
            
            //if a restart file is given 
            std::size_t found = getName().find(".restart");
            if (found == std::string::npos)
            {
                logger(INFO, "Reading file %\n", Flusher::NO_FLUSH, restartFile.getName());
                readRestartFile();
            }
            else
            {
                logger(INFO, "Reading file %\n", Flusher::NO_FLUSH, argv[i + 1]);
                readRestartFile(argv[i + 1]);
                //setName(getName().substr(0,found));
                logger(INFO, "Read file %\n", Flusher::NO_FLUSH, getName());
            }
            logger(INFO, "tmax= %", getTimeMax());
            //restartFile.getFstream().precision(18);
            setAppend(true);
            printTime();
        }
        else
        {
            return Mercury3D::readNextArgument(i, argc, argv);
        }
        return true;
    }
    
    double getWallTime() const
    {
        struct timeval time;
        if (gettimeofday(&time, NULL))
        {
            logger(WARN, "Error in getWallTime: Wall time could not be read");
            return 0;
        }
        return (double) time.tv_sec + (double) time.tv_usec * .000001;
    }
 
private:
    
    /* writeOutputFiles is modified to force a restart when maxWallTime_ is 
     * reached. This is done by resetting the final simulation time to the 
     * current time.
     */
    void writeOutputFiles() override
    {
        Mercury3D::writeOutputFiles();
        
        if (getWallTime() - initialWallTime_ > maxWallTime_)
        {
            actionsAfterSolve();
            finishStatistics();
            closeFiles();
            logger(INFO, "Exiting for restarting after %s\n", Flusher::NO_FLUSH, getWallTime() - initialWallTime_);
            
            //set the restart command
            std::stringstream com("");
            //check if filename contaion a dot
            //this is so the code works for autonumbered files
            std::size_t found = getName().find('.');
            if (found == std::string::npos)
            {
                com << clusterCommand_ << " ./" << getName() << " -r " << getName();
            }
            else
            {
                com << clusterCommand_ << " ./" << getName().substr(0, found) << " -r " << getName();
            }
            //std::cout << com << std::endl;        
            logger(INFO, "system output:%", system(com.str().c_str()));
            exit(0);
        }
    }
    
    std::string clusterCommand_;
    
    double maxWallTime_;
    
    double initialWallTime_;
    
};
 
#endif