iaea_phsp_source.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ IAEA format phase-space source 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:          Blake Walters, 2013
#
#  Contributors:    Reid Townson
#
###############################################################################
*/


#ifndef IAEA_PHSP_SOURCE_
#define IAEA_PHSP_SOURCE_

#define MAXEXTRAS 10

#include "egs_vector.h"
#include "egs_base_source.h"
#include "egs_rndm.h"
#include "egs_alias_table.h"

#include <fstream>
using namespace std;

#ifdef WIN32

    #ifdef BUILD_IAEA_PHSP_SOURCE_DLL
        #define IAEA_PHSP_SOURCE_EXPORT __declspec(dllexport)
    #else
        #define IAEA_PHSP_SOURCE_EXPORT __declspec(dllimport)
    #endif
    #define IAEA_PHSP_SOURCE_LOCAL

#else

    #ifdef HAVE_VISIBILITY
        #define IAEA_PHSP_SOURCE_EXPORT __attribute__ ((visibility ("default")))
        #define IAEA_PHSP_SOURCE_LOCAL  __attribute__ ((visibility ("hidden")))
    #else
        #define IAEA_PHSP_SOURCE_EXPORT
        #define IAEA_PHSP_SOURCE_LOCAL
    #endif

#endif

class IAEA_PHSP_SOURCE_EXPORT IAEA_PhspSource : public EGS_BaseSource {

public:

    IAEA_PhspSource(const string &phsp_file,
                    const string &Name="", EGS_ObjectFactory *f=0);

    IAEA_PhspSource(EGS_Input *, EGS_ObjectFactory *f=0);
    ~IAEA_PhspSource() { };

    EGS_I64 getNextParticle(EGS_RandomGenerator *rndm,
                            int &q, int &latch, EGS_Float &E, EGS_Float &wt,
                            EGS_Vector &x, EGS_Vector &u);
    void setSimulationChunk(EGS_I64 nstart, EGS_I64 nrun);
    EGS_Float getEmax() const {
        return Emax;
    };
    EGS_Float getFluence() const {
        double aux = ((double) Nread)/((double) Nparticle);
        return Pinc*aux;
    };
    EGS_Float getMu() {
        if (mu_stored) {
            return p.mu;
        }
        else {
            return -1.0;
        }
    };
    bool storeState(ostream &data) const {
        data << endl;
        bool res = egsStoreI64(data,Nread);
        if (!res) {
            return res;
        }
        data << "  ";
        res = egsStoreI64(data,Nfirst);
        if (!res) {
            return res;
        }
        data << "  ";
        res = egsStoreI64(data,Nlast);
        if (!res) {
            return res;
        }
        data << "  ";
        res = egsStoreI64(data,Npos);
        if (!res) {
            return res;
        }
        data << "  ";
        res = egsStoreI64(data,count);
        if (!res) {
            return res;
        }
        data << "  ";
        return res;
    };
    bool setState(istream &data) {
        first = false;
        bool res = egsGetI64(data,Nread);
        if (!res) {
            return res;
        }
        res = egsGetI64(data,Nfirst);
        if (!res) {
            return res;
        }
        res = egsGetI64(data,Nlast);
        if (!res) {
            return res;
        }
        res = egsGetI64(data,Npos);
        if (!res) {
            return res;
        }
        Npos++;
        iaea_set_record(&iaea_fileid,&Npos,&iaea_iostat);
        res = egsGetI64(data,count);
        return res;
    };
    bool addState(istream &data) {
        EGS_I64 tmp_Nread = Nread, tmp_count = count;
        bool res = setState(data);
        Nread += tmp_Nread;
        count += tmp_count;
        return res;
    };
    void resetCounter() {
        Nread = 0;
        count = 0;
    };

    bool isValid() const {
        return is_valid;
    };

    void setCutout(EGS_Float xmin, EGS_Float xmax, EGS_Float ymin,
                   EGS_Float ymax) {
        Xmin = xmin;
        Xmax = xmax;
        Ymin = ymin;
        Ymax = ymax;
    };
    void setFilter(int, int, int, const int *);

protected:

    bool        is_valid;
    string      the_file_name; 
    bool        mode2;         
    bool        latch_stored;  
    bool        mu_stored;  
    bool        swap_bytes;    
    EGS_Float   Emax,    
                Pinc;    
    EGS_I64     Nparticle, 
                Nphoton,   
                Nread,     
                Npos,      
                Nfirst,    
                Nlast,     
                count;     
    int         Nrestart;  
    int         Nrecycle_g;  
    int         Nrecycle_e;  
    int         Nrecycle;    
    int         Nuse;      
    int         iaea_iostat; 
    int         iaea_fileid; 
    int         n_extra_floats; 
    int         n_extra_longs; 
    int         i_zlast;   
    int         i_mu;   
    int         i_latch;   

    bool        first;

    // filters
    int         particle_type;
    int         filter_type;
    unsigned long filter1, filter2;
    EGS_Float   Xmin, Xmax, Ymin, Ymax;
    EGS_Float   wmin, wmax; // weight window

    void openFile(const string &);
    void init();

#ifndef SKIP_DOXYGEN
    struct EGS_LOCAL BeamParticle {
        int  latch, q;
        float E, u, v, w, x, y, z, wt, zlast, mu;
    };
    BeamParticle  p;
#endif

    inline bool rejectParticle() const;

};

#endif