egs_autoenvelope_REMOTE_785542.h

/*
###############################################################################
#
#  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
#                   Martin Martinov
#                   Alexandre Demelo
#
###############################################################################
#
#  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;
 
    void getNextGeom(EGS_RandomGenerator *rndm);
 
    void updatePosition(EGS_Float time);
 
    void containsDynamic(bool &hasdynamic);
 
    bool hasRhoScaling() override;
 
    void finishInitialization() override;
 
    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