egs_run_control.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ run control headers
#  Copyright (C) 2015 National Research Council Canada
#
#  This file is part of EGSnrc.
#
#  EGSnrc is free software: you can redistribute it and/or modify it under
#  the terms of the GNU Affero General Public License as published by the
#  Free Software Foundation, either version 3 of the License, or (at your
#  option) any later version.
#
#  EGSnrc 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 Affero General Public License for
#  more details.
#
#  You should have received a copy of the GNU Affero General Public License
#  along with EGSnrc. If not, see <http://www.gnu.org/licenses/>.
#
###############################################################################
#
#  Author:          Iwan Kawrakow, 2005
#
#  Contributors:    Frederic Tessier
#                   Ernesto Mainegra-Hing
#                   Blake Walters
#                   Reid Townson
#
###############################################################################
*/
 
 
#ifndef EGS_RUN_CONTROL_
#define EGS_RUN_CONTROL_
 
#include "egs_libconfig.h"
#include "egs_timer.h"
 
#include <iostream>
using namespace std;
 
class EGS_Application;
class EGS_Input;
 
class EGS_EXPORT EGS_RunControl {
 
public:
 
    EGS_RunControl(EGS_Application *app);
 
    virtual ~EGS_RunControl();
 
    void setNcase(EGS_I64 n) {
        if (n > 0) {
            ncase = n;
        }
    };
 
    void setNbatch(int n) {
        if (n > 0) {
            nbatch = n;
        }
    };
 
    void setMaxTime(EGS_Float t) {
        maxt = t;
    };
 
    void setRequiredUncertainty(EGS_Float a) {
        accu = a;
    };
 
    EGS_I64 getNcase() const {
        return ncase;
    };
 
    int     getNbatch() const {
        return nbatch;
    };
 
    int     getNchunk() const {
        return nchunk;
    };
 
    virtual int     startSimulation();
 
    virtual EGS_I64 getNextChunk() {
        return getNcase() - ndone;
    };
 
    virtual int     finishSimulation();
 
    virtual bool    startBatch(int,EGS_I64);
 
    virtual bool    finishBatch();
 
    virtual void    describeRCO();
    virtual bool    storeState(ostream &data);
    virtual bool    setState(istream &data);
    virtual bool    addState(istream &data);
    virtual void    resetCounter();
    virtual bool    getCombinedResult(double &, double &) const {
        return false;
    };
 
    virtual EGS_I64 getNdone() const {
        return ndone;
    };
 
    virtual void    setNdone(EGS_I64 Ndone) {
        ndone = Ndone;
    };
 
    virtual void    incrementNdone() {
        ++ndone;
    };
 
    virtual EGS_Float getCPUTime() const {
        return cpu_time+previous_cpu_time;
    };
 
    enum RCOType {
        simple,   
        uniform,  
        balanced  
    };
 
    static EGS_RunControl *getRunControlObject(EGS_Application *);
 
    int             geomErrorCount, geomErrorMax;
 
protected:
 
    EGS_Application *app;
    EGS_Input       *input;
 
    EGS_I64         ncase;  // number of histories.
    EGS_I64         ndone;  // histories done so far.
    EGS_Float       maxt;   // maximum time to run in hours.
    EGS_Float       accu;   // statistical uncertainty sought.
    int             nbatch; // number of batches.
    int             restart;// =0 => fresh calculation
    // =1 => restart calculation
    // =2 => analyze results
    // =3 => combine parallel run
    int             nchunk; // number of simulation "chunks"
 
    RCOType         rco_type; 
 
    EGS_Timer       timer;
    EGS_Float       cpu_time;
    EGS_Float       previous_cpu_time;
 
};
 
class EGS_FileLocking;
 
class EGS_EXPORT EGS_JCFControl : public EGS_RunControl {
 
public:
 
    EGS_JCFControl(EGS_Application *, int Nbuf=1024);
    ~EGS_JCFControl();
    void setNchunkForParallel(int n) {
        if (n > 0) {
            nchunk = n;
        }
    };
    int  startSimulation();
    EGS_I64 getNextChunk();
    int  finishSimulation();
    bool getCombinedResult(double &, double &) const;
 
protected:
 
    EGS_I64 nleft, ntot;
    double  tsum, tsum2, tcount, norm;
    double  last_sum, last_sum2, last_count;
    unsigned long start_time;
    int    njob;
    int    npar;
    int    ipar;
    int    ifirst;
    bool   first_time;
    bool   removed_jcf;
    int    nbuf;
    char   *buf;
 
    EGS_FileLocking *p;
 
    bool   createControlFile();
    bool   openControlFile();
    bool   closeControlFile();
    bool   lockControlFile();
    bool   unlockControlFile();
    bool   rewindControlFile();
    bool   readControlFile();
    bool   writeControlFile();
    virtual bool writeControlString();
    virtual bool readControlString();
 
};
 
class EGS_EXPORT EGS_UniformRunControl : public EGS_RunControl {
 
public:
 
    EGS_UniformRunControl(EGS_Application *app);
    ~EGS_UniformRunControl() {};
 
    void  describeRCO();
 
    int  startSimulation();
 
    int  finishSimulation();
 
protected:
 
    int milliseconds;   // time interval for checking
    // if all jobs finished (default 1000 ms)
 
    int check_intervals;// Number of intervals to check
    // if all jobs done (default 5)
 
    int    njob;
    int    npar;
    int    ipar;
    int    ifirst;
    bool   check_egsdat;// If true, and a 'watcher' job, produce intermediate results
    bool   watcher_job; // If true, job is a 'watcher'
};
 
#endif