egs_phsp_source.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ 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:          Iwan Kawrakow, 2005
#
#  Contributors:    Frederic Tessier
#                   Reid Townson
#
###############################################################################
*/


#ifndef EGS_PHSP_SOURCE_
#define EGS_PHSP_SOURCE_

#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_PHSP_SOURCE_DLL
        #define EGS_PHSP_SOURCE_EXPORT __declspec(dllexport)
    #else
        #define EGS_PHSP_SOURCE_EXPORT __declspec(dllimport)
    #endif
    #define EGS_PHSP_SOURCE_LOCAL

#else

    #ifdef HAVE_VISIBILITY
        #define EGS_PHSP_SOURCE_EXPORT __attribute__ ((visibility ("default")))
        #define EGS_PHSP_SOURCE_LOCAL  __attribute__ ((visibility ("hidden")))
    #else
        #define EGS_PHSP_SOURCE_EXPORT
        #define EGS_PHSP_SOURCE_LOCAL
    #endif

#endif

class EGS_PHSP_SOURCE_EXPORT EGS_PhspSource : public EGS_BaseSource {

public:

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

    EGS_PhspSource(EGS_Input *, EGS_ObjectFactory *f=0);
    ~EGS_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;
    };
    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;
        }
        the_file.seekg((Npos+1)*recl,ios::beg);
        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; 
    ifstream    the_file;      
    int         recl;          
    bool        mode2;         
    bool        swap_bytes;    
    char       *record;        
    EGS_Float   Emax,    
                Emin,    
                Pinc;    
    EGS_I64     Nparticle, 
                Nphoton,   
                Nread,     
                Npos,      
                Nfirst,    
                Nlast,     
                count;     
    int         Nrestart;  
    int         Nrecycle_g;  
    int         Nrecycle_e;  
    int         Nrecycle;    
    int         Nuse;      

    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, x, y, wt;
    };
    BeamParticle  p;
#endif

    inline void readParticle();
    inline bool rejectParticle() const;

};

#endif