egs_autoenvelope.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ auto envelope geometry headers
#  Copyright (C) 2016 Randle E. P. Taylor, Rowan M. Thomson,
#  Marc J. P. Chamberland, D. W. O. Rogers
#
#  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:          Randle Taylor, 2016
#
#  Contributors:    Marc Chamberland
#                   Rowan Thomson
#                   Dave Rogers
#
###############################################################################
#
#  egs_autoenvelope was developed for the Carleton Laboratory for
#  Radiotherapy Physics.
#
###############################################################################
*/


#ifndef EGS_AENVELOPE_GEOMETRY_
#define EGS_AENVELOPE_GEOMETRY_

#ifdef WIN32

    #ifdef BUILD_AENVELOPE_DLL
        #define EGS_AENVELOPE_EXPORT __declspec(dllexport)
    #else
        #define EGS_AENVELOPE_EXPORT __declspec(dllimport)
    #endif
    #define EGS_AENVELOPE_LOCAL

#else

    #ifdef HAVE_VISIBILITY
        #define EGS_AENVELOPE_EXPORT __attribute__ ((visibility ("default")))
        #define EGS_AENVELOPE_LOCAL  __attribute__ ((visibility ("hidden")))
    #else
        #define EGS_AENVELOPE_EXPORT
        #define EGS_AENVELOPE_LOCAL
    #endif

#endif


#include "egs_base_geometry.h"
#include "egs_functions.h"
#include "egs_transformations.h"
#include "egs_shapes.h"
#include "volcor.h"

#include<vector>
#include<algorithm>
#include<map>
#include<set>


using std::vector;
using namespace volcor;


struct EGS_AENVELOPE_LOCAL AEnvelopeAux {
    EGS_BaseGeometry *geom;
    EGS_AffineTransform *transform;
    volcor::VCOptions *vcopts;

    AEnvelopeAux(EGS_BaseGeometry *geom, EGS_AffineTransform *transform, volcor::VCOptions *vcopts):
        geom(geom), transform(transform), vcopts(vcopts) {};
};

class EGS_AENVELOPE_EXPORT EGS_AEnvelope : public EGS_BaseGeometry {


public:

    EGS_AEnvelope(EGS_BaseGeometry *base_geom,
                  const vector<AEnvelopeAux> inscribed, const string &Name = "", bool debug=false, string output_vc_file="no");

    ~EGS_AEnvelope();

    int getGlobalRegFromLocalReg(EGS_BaseGeometry *g, int local_reg);

    int getGlobalRegFromLocal(const volcor::GeomRegPairT local) const;

    volcor::GeomRegPairT getLocalFromGlobalReg(int ireg) const;

    int getNRegWithInscribed() const;

    bool isRealRegion(int ireg) const;

    bool isInside(const EGS_Vector &x);

    int isWhere(const EGS_Vector &x);

    int inside(const EGS_Vector &x);

    int medium(int ireg) const;

    virtual vector<EGS_BaseGeometry *> getGeomsInRegion(int ireg);

    int computeIntersections(int ireg, int n, const EGS_Vector &X,
                             const EGS_Vector &u, EGS_GeometryIntersections *isections);


    EGS_Float howfarToOutside(int ireg, const EGS_Vector &x, const EGS_Vector &u);

    int howfar(int ireg, const EGS_Vector &x, const EGS_Vector &u,
               EGS_Float &t, int *newmed = 0, EGS_Vector *normal = 0);

    EGS_Float hownear(int ireg, const EGS_Vector &x);

    bool hasBooleanProperty(int ireg, EGS_BPType prop) const;

    void setBooleanProperty(EGS_BPType);

    void addBooleanProperty(int);

    void setBooleanProperty(EGS_BPType,int,int,int step=1);

    void addBooleanProperty(int,int,int,int step=1);

    int getMaxStep() const;

    virtual EGS_Float getVolume(int ireg);

    virtual EGS_Float getCorrectionRatio(int ireg);

    virtual const string &getType() const {
        return type;
    };

    void printInfo() const;

    void setRelativeRho(int start, int end, EGS_Float rho);
    void setRelativeRho(EGS_Input *);

    EGS_Float getRelativeRho(int ireg) const;

    static vector<EGS_AffineTransform *> createTransforms(EGS_Input *inpt);


    static bool allowedBaseGeomType(const string &geom_type);


protected:

    EGS_BaseGeometry *base_geom;           
    vector<EGS_BaseGeometry *> inscribed_geoms; 
    vector<EGS_AffineTransform *> transforms; 
    vector<volcor::VCOptions *> opts; 
    int nregbase;   
    int ninscribed;   
    int nreg_with_inscribed;

    bool debug_info;
    string output_vc;
    volcor::VCResults vc_results;

    // conversions from inscribed to global region numbers and vice versa
    map<volcor::GeomRegPairT, int> local_to_global_reg;
    map<int, volcor::GeomRegPairT> global_reg_to_local;

    //keep track of which geometries are present in which base geometry regions
    vector<EGS_BaseGeometry *> *geoms_in_region;

    static string type;    

    const static string allowed_base_geom_types[];

    void setMedia(EGS_Input *,int,const int *);

    double findRegionsInscribedIn(vector<EGS_BaseGeometry *>, vector<EGS_AffineTransform *>, volcor::VCOptions *);
    double loadFileVolumeCorrections(vector<EGS_BaseGeometry *>, vector<EGS_AffineTransform *>, volcor::VCOptions *);

    void applyVolumeCorrections(volcor::VCOptions *opts, volcor::HitCounterT hit_counter);

    void writeVCToFile(ostream &);
    void writeVolumeCorrection();

private:

    void setPropertyError(const char *funcname) {
        egsFatal("EGS_AEnvelope::%s: don't use this method\n  Define "
                 "properties in the constituent geometries instead\n",
                 funcname);
    };

    bool getHasRhoScaling();

};

class EGS_AENVELOPE_EXPORT EGS_ASwitchedEnvelope : public EGS_AEnvelope {

private:

    vector<EGS_BaseGeometry *> active_inscribed;
    int cur_ptr;

protected:

    static string type;    

    vector<EGS_BaseGeometry *> getGeomsInRegion(int ireg);

public:

    EGS_ASwitchedEnvelope(EGS_BaseGeometry *base_geom,
                          const vector<AEnvelopeAux> inscribed, const string &Name = "", bool debug=false, string output_vc_file="no");

    const string &getType() const {
        return type;
    };

    void setActiveGeometries(vector<EGS_BaseGeometry *> geoms);

    void setActiveGeometries(vector<int> geom_indexes);

    bool hasActiveGeom(int ireg);

    bool hasInactiveGeom(int ireg);

    void setActiveByIndex(int inscribed_index);

    void activateByIndex(int inscribed_index);

    void deactivateByIndex(int inscribed_index);

    void cycleActive();

};

#endif