egs_application.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ application 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
#                   Alexandre Demelo
#
###############################################################################
*/
 
 
#ifndef EGS_APPLICATION_
#define EGS_APPLICATION_
 
#include "egs_base_geometry.h"
#include "egs_base_source.h"
#include "egs_simple_container.h"
#include "egs_interpolator.h"
 
#include <string>
#include <iostream>
using namespace std;
 
class EGS_Input;
class EGS_BaseSource;
class EGS_RandomGenerator;
class EGS_RunControl;
class EGS_GeometryHistory;
class EGS_AusgabObject;
class EGS_Interpolator;
//template <class T> class EGS_SimpleContainer;
 
struct EGS_Particle {
    int        q;      
    int        latch;  
    int        ir;     
    EGS_Float  E;      
    EGS_Float  wt;     
    EGS_Vector x;      
    EGS_Vector u;      
};
 
class EGS_EXPORT EGS_Application {
 
public:
 
    EGS_Application(int argc, char **argv);
 
    virtual ~EGS_Application();
 
    virtual int initSimulation();
 
    virtual void setSimulationChunk(EGS_I64 nstart, EGS_I64 nrun, int npar, int nchunk);
 
    virtual int runSimulation();
 
    virtual int finishSimulation();
 
    virtual void describeSimulation();
 
    virtual int simulateSingleShower();
 
    virtual void getCurrentResult(double &sum, double &sum2, double &norm,
                                  double &count) {
        sum = 0;
        sum2 = 0;
        norm = 1;
        count = 0;
    };
 
    virtual void analyzeResults() {};
 
    virtual void outputResults() {};
 
    virtual int combineResults();
 
    virtual int combinePartialResults();
 
    int howManyJobsDone();
 
 
    virtual int  outputData();
 
    virtual int  readData();
 
    EGS_Input *getInput() {
        return input;
    };
 
    const string &getAppName() const {
        return app_name;
    };
 
    const string &getEgsHome() const {
        return egs_home;
    };
 
    const string &getHenHouse() const {
        return hen_house;
    };
 
    const string &getOutputFile() const {
        return output_file;
    };
 
    const string &getFinalOutputFile() const {
        return final_output_file;
    };
 
    string constructIOFileName(const char *extension, bool with_run_dir) const;
 
    const string &getAppDir() const {
        return app_dir;
    };
 
    const string &getRunDir() const {
        return run_dir;
    };
 
    const string &getWorkDir() const {
        return run_dir;
    };
 
    enum AusgabCall {
        BeforeTransport = 0,     
        EgsCut = 1,              
        PegsCut = 2,             
        UserDiscard = 3,         
        ExtraEnergy = 4,         
        AfterTransport = 5,      
        BeforeBrems = 6,         
        AfterBrems = 7,          
        BeforeMoller = 8,        
        AfterMoller = 9,         
        BeforeBhabha = 10,       
        AfterBhabha = 11,        
        BeforeAnnihFlight = 12,  
        AfterAnnihFlight = 13,   
        BeforeAnnihRest = 28,    
        AfterAnnihRest = 14,     
        BeforePair = 15,         
        AfterPair = 16,          
        BeforeCompton = 17,      
        AfterCompton = 18,       
        BeforePhoto = 19,        
        AfterPhoto = 20,         
        EnteringUphi = 21,       
        LeavingUphi = 22,        
        BeforeRayleigh = 23,     
        AfterRayleigh = 24,      
        FluorescentEvent = 25,   
        CosterKronigEvent = 26,  
        AugerEvent = 27,         
        BeforePhotoNuc = 29,     
        AfterPhotoNuc = 30,      
        BeforeEII = 31,          
        AfterEII = 32,           
        AfterSubPhoton = 33,     
        AfterSubElectron = 34,   
        UnknownCall = 35         
    };
 
    virtual void setAusgabCall(AusgabCall call, bool on_or_off) {
        ausgab_flag[call] = on_or_off;
    };
 
    int getNparallel() const {
        return n_parallel;
    };
 
    int getIparallel() const {
        return i_parallel;
    };
 
    int getFirstParallel() const {
        return first_parallel;
    };
 
    inline int howfar(int ireg, const EGS_Vector &x, const EGS_Vector &u,
                      EGS_Float &t, int *newmed) {
 
        geometry->resetErrorFlag();
        EGS_Float twant = t;
        int inew = geometry->howfar(ireg,x,u,t,newmed);
        storeGeometryStep(ireg,inew,x,u,twant,t);
        if (geometry->getLastError()) {
            reportGeometryError();
        }
        return inew;
 
        //return geometry->howfar(ireg,x,u,t,newmed);
    };
 
    inline EGS_Float hownear(int ireg,const EGS_Vector &x) {
        return geometry->hownear(ireg,x);
    };
 
    inline int getMedium(int ireg) {
        return geometry->medium(ireg);
    };
 
    bool isRealRegion(int ireg) {
        return geometry->isRealRegion(ireg);
    }
    int  isWhere(EGS_Vector &r) {
        return geometry->isWhere(r);
    }
 
    void getNumberRegions(const string &str, vector<int> &regs) {
        geometry->getNumberRegions(str, regs);
    }
 
    void getLabelRegions(const string &str, vector<int> &regs) {
        geometry->getLabelRegions(str, regs);
    }
 
    EGS_Float getTimeIndex() {
        return source->getTimeIndex();
    }
 
    void setTimeIndex(EGS_Float temp_time) {
        source->setTimeIndex(temp_time);
    }
 
    int userScoring(int iarg, int ir=-1);
 
    virtual int ausgab(int) {
        return 0;
    };
 
    virtual void startNewParticle() { };
 
    virtual void enterNewRegion() { };
 
    virtual void fillRandomArray(int n, EGS_Float *rns);
 
    static EGS_Application *activeApplication();
 
    static void setActiveApplication(EGS_Application *);
 
    virtual EGS_I64 randomNumbersUsed() const;
 
    virtual void getElectronSteps(double &ch_steps, double &all_steps) const {
        ch_steps = 0;
        all_steps = 0;
    };
 
    virtual int addState(istream &data);
 
    virtual void resetCounter();
 
    virtual void describeUserCode() const {};
 
    virtual void appInformation(const char *);
 
    virtual void appWarning(const char *);
 
    virtual void appFatal(const char *);
 
    void checkDeviceFull(FILE *);
 
    static bool getArgument(int &argc, char **argv,
                            const char *name1, const char *name2, string &arg);
 
    static void checkEnvironmentVar(int &argc, char **argv, const char *env,
                                    const char *n1, const char *n2, string &var);
 
protected:
 
    virtual int initGeometry();
 
    virtual int initSource();
 
    virtual int initCrossSections() {
        return 0;
    };
 
    virtual int initScoring() {
        return 0;
    };
 
    virtual int initRunControl();
 
    virtual int initRNG();
 
    virtual int initEGSnrcBackEnd() {
        return 0;
    };
 
    void initAusgabObjects();
 
    void addAusgabObject(EGS_AusgabObject *o);
 
    virtual int startNewShower();
 
    virtual int finishShower() {
        return 0;
    };
 
    virtual int shower() {
        return 0;
    };
 
    virtual void finishRun() { };
 
    void storeGeometryStep(int ireg, int inew, const EGS_Vector &x,
                           const EGS_Vector &u, EGS_Float twant, EGS_Float t);
 
    void reportGeometryError();
 
    EGS_Input           *input;         
    EGS_BaseGeometry    *geometry;      
    EGS_BaseSource      *source;        
    EGS_RandomGenerator *rndm;          
    EGS_RunControl      *run;           
 
    bool    ausgab_flag[UnknownCall]; 
 
    string  app_name;           
    string  egs_home;           
    string  hen_house;          
    string  app_dir;            
    string  run_dir;            
    string  egs_config;         
    string  input_file;         
    string  output_file;        
    string  final_output_file;  
    string  pegs_file;          
    string  abs_pegs_file;      
 
    int     n_parallel,  
            i_parallel,  
            first_parallel; 
    bool    batch_run;   
    bool    simple_run;  
    bool    uniform_run; 
    bool    is_pegsless; 
 
    EGS_Particle p;      
    EGS_I64      current_case; 
    EGS_I64      last_case;    
 
    ostream *data_out;
 
    istream *data_in;
 
    int app_index;
 
    EGS_SimpleContainer<EGS_AusgabObject *> a_objects_list;
 
    EGS_SimpleContainer<EGS_AusgabObject *> *a_objects;
 
    EGS_GeometryHistory *ghistory;
 
private:
 
    static int n_apps; 
 
public:
 
    EGS_Particle top_p;  
    int          Np;     
    //************************************************************
    // Utility functions for use with ausgab dose scoring objects
    //************************************************************
    EGS_Float getFluence() {
        return source->getFluence();
    };
    int       getnRegions() {
        return geometry->regions();
    };
    int       getnMedia() {
        return geometry->nMedia();
    };
    const char *getMediumName(int ind) {
        return geometry->getMediumName(ind);
    };
    virtual EGS_Float getMediumRho(int ind) {
        return -1.0;
    };
    virtual EGS_Float getEdep() {
        return 0.0;
    };
    virtual void setEdep(EGS_Float edep) {};
    virtual EGS_Float getEcut() {
        return 0.0;
    };
    virtual EGS_Float getPcut() {
        return 0.0;
    };
    virtual EGS_Float getRM() {
        return -1.0;
    };
 
    //************************************************
    // For use with ausgab radiative splitting objects
    //************************************************
    virtual void setRadiativeSplitting(const EGS_Float &nsplit) {};
    virtual void setRussianRoulette(const EGS_Float &iSwitchRR) {};
    virtual void splitTopParticleIsotropically(const EGS_Float &fsplit) {}
 
    //************************************************************
    // Utility functions for use with ausgab fluence scoring objects
    //************************************************************
    virtual EGS_Float getTVSTEP() {
        return 0.0;
    };
 
    virtual EGS_Interpolator *getDEDX(const int &imed, const int &iq) {
        return 0;
    };
 
    string sourceType() {
        return source->getObjectType();
    }
 
    int sourceCharge() {
        return source->getCharge();
    }
 
    int sourceEmax() {
        return source->getEmax();
    }
 
    virtual void setLatch(const int &ip, const int &latch) {};
 
    virtual void incLatch(const int &ip, const int &increment) {};
 
    virtual int getNp() {
        return 0;
    };
 
    virtual int getNpOld() {
        return 0;
    };
 
    //************************************************************
    // Utility function for ausgab phase space scoring objects
    //************************************************************
    virtual void setLatch(int latch) {};
 
    bool containsDynamic() {
        bool hasDynamic = false;
        geometry->containsDynamic(hasDynamic);
        if (!hasDynamic) {
            source->containsDynamic(hasDynamic);
        }
        return hasDynamic;
    }
};
 
#define APP_MAIN(app_name) \
    int main(int argc, char **argv) { \
        app_name app(argc,argv); \
        int err = app.initSimulation(); \
        if( err ) return err; \
        err = app.runSimulation(); \
        if( err < 0 ) return err; \
        return app.finishSimulation(); \
    }
 
#define APP_SIMPLE_MAIN(app_name) \
    int main(int argc, char **argv) { \
        app_name app(argc,argv); \
        app.run(); \
        app.reportResults(); \
        app.finish(); \
        return 0; \
    }
 
#define APP_LIB(app_name) \
    extern "C" {\
        APP_EXPORT EGS_Application* createApplication(int argc, char **argv) {\
            return new app_name(argc,argv);\
        }\
    }
 
 
#endif