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
#
###############################################################################
*/


#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);

    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 getMU() {
        return source->getMu();
    }

    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;
    };
    virtual void setRadiativeSplitting(const EGS_Float &nsplit) {};

    //************************************************************
    // 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) {};

};

#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