source: issm/trunk-jpl/src/m/solve/solve.js@ 22880

function solve(md, solutionstring) {//{{{
/**
 * SOLVE - apply solution sequence for this model
 *
 *      Usage:
 *              solve(md, solutionstring, varargin);
 *              where varargin is a list of paired arguments of string OR enums
 *
 *      solution types available comprise:
 *              - 'Stressbalance'               or 'sb'
 *              - 'Masstransport'               or 'mt'
 *              - 'Thermal'                             or 'th'
 *              - 'Steadystate'                 or 'ss'
 *              - 'Transient'                   or 'tr'
 *              - 'Balancethickness'    or 'mc'
 *              - 'Balancevelocity'             or 'bv'
 *              - 'BedSlope'                    or 'bsl'
 *              - 'SurfaceSlope'                or 'ssl'
 *              - 'Hydrology'                   or 'hy'
 *              - 'DamageEvolution'             or 'da'
 *              - 'Gia'                                 or 'gia'
 *              - 'Sealevelrise'                or 'slr'
 *
 *      extra options:
 *              - loadonly              : do not solve, only load results
 *              - runtimename           : true or false (default is true), makes name unique
 *              - checkconsistency      : 'yes' or 'no' (default is 'yes'), ensures checks on consistency of model
 *              - restart                       : directory name (relative to the execution directory) where the restart file is located
 *              - successCallback       : callback function to be called on success
 *              - errorCallback         : callback function to be called on error
 *
 *      reporting:
 *              With no optional arguments for reporting, progress and error reporting is written to the DOM element with ID 'solve-button'.
 *              - solveButtonId         : overrides default solve button ID
 *              - callout                       : Callout to report progress/errors to; overrides reporting to solve button
 *              - withProgressBar       : reports progress of certain solution stages with a progress bar; will not display if a Callout has not been provided
 *
 *      Examples:
 *              md = solve(md, 'Stressbalance');
 *              md = solve(md, 'sb');
 */
        if (typeof solutionstring !== 'string') {
                throw Error(sprintf("%s\n", "ISSM's solve function only accepts strings for solution sequences. Type help solve to get a list of supported solutions."));
        }

        //recover and process solve options
        let solutionStringLowerCase = solutionstring.toLowerCase();
        
        if ((solutionStringLowerCase === 'sb') || (solutionStringLowerCase === 'stressbalance')) {
                solutionstring = 'StressbalanceSolution';
        } else if ((solutionStringLowerCase === 'mt') || (solutionStringLowerCase === 'masstransport')) {
                solutionstring = 'MasstransportSolution';       
        } else if ((solutionStringLowerCase === 'th') || (solutionStringLowerCase === 'thermal')) {
                solutionstring = 'ThermalSolution';
        } else if ((solutionStringLowerCase === 'st') || (solutionStringLowerCase === 'steadystate')) {
                solutionstring = 'SteadystateSolution';
        } else if ((solutionStringLowerCase === 'tr') || (solutionStringLowerCase === 'transient')) {
                solutionstring = 'TransientSolution';
        } else if ((solutionStringLowerCase === 'mc') || (solutionStringLowerCase === 'balancethickness')) {
                solutionstring = 'BalancethicknessSolution';
        } else if ((solutionStringLowerCase === 'bv') || (solutionStringLowerCase === 'balancevelocity')) {
                solutionstring = 'BalancevelocitySolution';
        } else if ((solutionStringLowerCase === 'bsl') || (solutionStringLowerCase === 'bedslope')) {
                solutionstring = 'BedSlopeSolution';
        } else if ((solutionStringLowerCase === 'ssl') || (solutionStringLowerCase === 'surfaceslope')) {
                solutionstring = 'SurfaceSlopeSolution';
        } else if ((solutionStringLowerCase === 'hy') || (solutionStringLowerCase === 'hydrology')) {
                solutionstring = 'HydrologySolution';
        } else if ((solutionStringLowerCase === 'da') || (solutionStringLowerCase === 'damageevolution')) {
                solutionstring = 'DamageEvolutionSolution';
        } else if ((solutionStringLowerCase === 'gia') || (solutionStringLowerCase === 'gia')) {
                solutionstring = 'GiaSolution';
        } else if ((solutionStringLowerCase === 'slr') || (solutionStringLowerCase === 'sealevelrise')) {
                solutionstring = 'SealevelriseSolution';
        } else {
                throw Error(sprintf("%s%s%s\n",'solutionstring ',solutionstring,' not supported!'));
        }
        
        // Process options
        let args        = Array.prototype.slice.call(arguments);
        let options = new pairoptions(args.slice(2, args.length));
        options.addfield('solutionstring', solutionstring);

        // recover some fields
        md.priv.solution        = solutionstring;
        cluster                         = md.cluster;

        //check model consistency
        if (options.getfieldvalue('checkconsistency', 'yes') === 'yes') {
                if (md.verbose.solution) {
                        console.log('checking model consistency');
                }
                
                ismodelselfconsistent(md);
        }

        // If we are restarting, actually use the provided runtime name:
        restart = options.getfieldvalue('restart', '');

        // First, build a runtime name that is unique
        if (restart === 1 ) {
                // Leave the runtimename as is
        } else {
                if (!(restart === '')) {
                        md.priv.runtimename=restart;
                } else if (options.getfieldvalue('runtimename',true)) {
                        let c = new Date().getTime();
                        md.priv.runtimename = sprintf('%s-%g', md.miscellaneous.name, c);
                } else {
                        md.priv.runtimename = md.miscellaneous.name;
                }
        }

        // If running qmu analysis, some preprocessing of dakota files using models fields needs to be carried out
        if (md.qmu.isdakota) {
                throw Error("solve error message: qmu runs not supported yet!");
                //md.preqmu(options);
        }

        // Do we load results only?
        if (options.getfieldvalue('loadonly', false)){
                loadresultsfromcluster(md);
                return;
        }

        // Marshall into a binary array (fid) all the fields of model
        let fid = marshall(md); // bin file
        
        //deal with toolkits options: 
        toolkitsstring = md.toolkits.ToolkitsFile(md.miscellaneous.name + '.toolkits'); // toolkits file


        /*
                Set success callback function
                
                Default: do nothing if no success callback function requested
        */
        //{{{
        function successCallbackDefault() {
                solving = false;
        }; 
        
        let successCallback = options.getfieldvalue('successCallback', successCallbackDefault);
        //}}}
        
        
        /*
                Set error callback function
                
                Default: do nothing if no error callback function requested
        */
        //{{{ 
        function errorCallbackDefault() {
                solving = false;
        }; 
        
        let errorCallback = options.getfieldvalue('errorCallback', errorCallbackDefault);
        //}}}
        
        
        /*
                Set solve button ID
                
                Default: update #solve-button element with progress updates
        */
        //{{{
        let solveButtonId = options.getfieldvalue('solveButtonId', '#solve-button');
        //}}}
        
        
        /*
                Set Callout
        */
        //{{{
        var callout = {};
        
        // Default: Callout is an empty object
        callout = options.getfieldvalue('callout', {});
        //}}}
        
        
        /*
                Set progress bar display boolean
                
                Default: no progress bar
                
                NOTE: must have supplied a callout for progress bar to display
        */
        //{{{
        let withProgressBar = options.getfieldvalue('withProgressBar', false);
        //}}}


        if (cluster.classname() === 'local') {//{{{

                // We are running locally on the machine, using the issm module
                console.log('running issm locally');
                
                // Call issm
                let outputs = issm(fid, toolkitsstring, solutionstring, md.miscellaneous.name); 
                
                // Recover output arguments:
                let outputbuffer                = outputs[0]; 
                let outputbuffersize    = outputs[1];
                        
                // Load results 
                md = loadresultsfrombuffer(md, outputbuffer, outputbuffersize); 
                
                // Call success callback 
                successCallback();

                return md;
        //}}}
        } else {//{{{
                // We are running somewhere else on a computational server. Send the buffer to that server and retrieve output.
                console.log('running issm remotely');
                
                cluster.UploadAndRun(
                        md, 
                        fid, 
                        toolkitsstring, 
                        solutionstring, 
                        md.miscellaneous.name, 
                        md.priv.runtimename,
                        successCallback, 
                        errorCallback, 
                        solveButtonId, 
                        callout, 
                        withProgressBar
                );

                return md;
        }//}}}
}//}}}