egs_collimated_source.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ collimated 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:    Ernesto Mainegra-Hing
#                   Reid Townson
#                   Hubert Ho
#                   Reid Townson
#
###############################################################################
*/
 
 
#ifndef EGS_COLLIMATED_SOURCE_
#define EGS_COLLIMATED_SOURCE_
 
#include "egs_vector.h"
#include "egs_base_source.h"
#include "egs_rndm.h"
#include "egs_shapes.h"
#include "egs_functions.h"
 
 
#ifdef WIN32
 
    #ifdef BUILD_COLLIMATED_SOURCE_DLL
        #define EGS_COLLIMATED_SOURCE_EXPORT __declspec(dllexport)
    #else
        #define EGS_COLLIMATED_SOURCE_EXPORT __declspec(dllimport)
    #endif
    #define EGS_COLLIMATED_SOURCE_LOCAL
 
#else
 
    #ifdef HAVE_VISIBILITY
        #define EGS_COLLIMATED_SOURCE_EXPORT __attribute__ ((visibility ("default")))
        #define EGS_COLLIMATED_SOURCE_LOCAL  __attribute__ ((visibility ("hidden")))
    #else
        #define EGS_COLLIMATED_SOURCE_EXPORT
        #define EGS_COLLIMATED_SOURCE_LOCAL
    #endif
 
#endif
 
class EGS_COLLIMATED_SOURCE_EXPORT EGS_CollimatedSource :
    public EGS_BaseSimpleSource {
 
public:
 
    EGS_CollimatedSource(int Q, EGS_BaseSpectrum *Spec,
                         EGS_BaseShape *sshape, EGS_BaseShape *tshape,
                         const string &Name="", EGS_ObjectFactory *f=0) :
        EGS_BaseSimpleSource(Q,Spec,Name,f), source_shape(sshape),
        target_shape(tshape), ctry(0), dist(1) {
        setUp();
    };
 
    EGS_CollimatedSource(EGS_Input *, EGS_ObjectFactory *f=0);
    ~EGS_CollimatedSource() {
        EGS_Object::deleteObject(source_shape);
        EGS_Object::deleteObject(target_shape);
    };
 
    void getPositionDirection(EGS_RandomGenerator *rndm,
                              EGS_Vector &x, EGS_Vector &u, EGS_Float &wt) {
        //x = source_shape->getPoint(rndm);
        x = source_shape->getRandomPoint(rndm);
        int ntry = 0;
        do {
            target_shape->getPointSourceDirection(x,rndm,u,wt);
            ntry++;
            if (ntry > 10000)
                egsFatal("EGS_CollimatedSource::getPositionDirection:\n"
                         "  my target shape %s, which is of type %s, failed to\n"
                         "  return a positive weight after 10000 attempts\n",
                         target_shape->getObjectName().c_str(),
                         target_shape->getObjectType().c_str());
        }
        while (wt <= 0);
        //egsInformation("got x=(%g,%g,%g) u=(%g,%g,%g) wt = %g ntry = %d\n",
        //        x.x,x.y,x.z,u.x,u.y,u.z,wt,ntry);
        ctry += ntry;
    };
 
    EGS_Float getFluence() const {
        double res = ctry;
        return res/(dist*dist);
    };
 
    bool storeFluenceState(ostream &data) const {
        return egsStoreI64(data,ctry);
    };
 
    bool setFluenceState(istream &data) {
        return egsGetI64(data,ctry);
    };
 
    bool addFluenceData(istream &data) {
        EGS_I64 tmp;
        bool ok = egsGetI64(data,tmp);
        if (!ok) {
            return false;
        }
        ctry += tmp;
        return true;
    };
 
    bool isValid() const {
        return (s != 0 && source_shape != 0 && target_shape != 0 &&
                target_shape->supportsDirectionMethod());
    };
 
    void resetFluenceCounter() {
        ctry = 0;
    };
 
protected:
 
    EGS_BaseShape *source_shape,  
                  *target_shape;  
    EGS_I64       ctry;           
    EGS_Float     dist;           
 
    void setUp();
 
};
 
#endif