egs_dynamic_geometry.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ dynamic_geometry geometry 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:          Alexandre Demelo 2023
#
#  Contributors:    Reid Townson
#
###############################################################################
*/
 
#ifndef EGS_DYNAMIC_GEOMETRY_
#define EGS_DYNAMIC_GEOMETRY_
 
#include "egs_base_geometry.h"
#include "egs_transformations.h"
#include "egs_rndm.h"
#include "egs_vector.h"
#include "egs_application.h"
#include <vector>
#include <string>
#include <sstream>
 
#ifdef WIN32
 
    #ifdef BUILD_DYNAMIC_GEOMETRY_DLL
        #define EGS_DYNAMIC_GEOMETRY_EXPORT __declspec(dllexport)
    #else
        #define EGS_DYNAMIC_GEOMETRY_EXPORT __declspec(dllimport)
    #endif
    #define EGS_DYNAMIC_GEOMETRY_LOCAL
 
#else
 
    #ifdef HAVE_VISIBILITY
        #define EGS_DYNAMIC_GEOMETRY_EXPORT __attribute__ ((visibility ("default")))
        #define EGS_DYNAMIC_GEOMETRY_LOCAL  __attribute__ ((visibility ("hidden")))
    #else
        #define EGS_DYNAMIC_GEOMETRY_EXPORT
        #define EGS_DYNAMIC_GEOMETRY_LOCAL
    #endif
 
#endif
 
class EGS_DYNAMIC_GEOMETRY_EXPORT EGS_DynamicGeometry :
    public EGS_BaseGeometry {
 
public:
 
    struct EGS_ControlPoint {
        EGS_Float time;             
        vector<EGS_Float> trnsl;    
        vector<EGS_Float> rot;      
    };
 
    EGS_DynamicGeometry(EGS_BaseGeometry *G, EGS_Input *dyninp, const string &Name = "") : EGS_BaseGeometry(Name), g(G) {
        type = g->getType() + "D";
        nreg = g->regions();
        is_convex = g->isConvex();
        has_rho_scaling = g->hasRhoScaling();
        has_B_scaling = g->hasBScaling();
        EGS_DynamicGeometry::buildDynamicGeometry(g, dyninp);
 
        if (cpts.size() < 2) {
            egsWarning("EGS_DynamicGeometry: not enough or missing control points.\n");
        }
        else {
            if (cpts[0].time > 0.0) {
                egsWarning("EGS_DynamicGeometry: time index of control point 1 > 0.0. This will generate many warning messages.\n");
            }
            int npts = cpts.size();
            for (int i = 0; i < npts; i++) {
                if (i > 0 && cpts[i].time < cpts[i - 1].time - epsilon) {
                    egsWarning("EGS_DynamicGeometry: time index of control point %i < time index of control point %i\n", i, i - 1);
                }
                if (cpts[i].time < 0.0) {
                    egsWarning("EGS_DynamicGeometry: time index of control point %i < 0.0\n", i);
                }
            }
            // Normalize time values
            for (int i = 0; i < npts - 1; i++) {
                cpts[i].time /= cpts[npts - 1].time;
            }
        }
 
    };
 
    ~EGS_DynamicGeometry() {
        if (!g->deref()) {
            delete g;
        }
    };
 
    void setTransformation(EGS_AffineTransform t) {
        T = t;
    };
 
    int computeIntersections(int ireg, int n, const EGS_Vector &x,
                             const EGS_Vector &u, EGS_GeometryIntersections *isections);
 
    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;
 
    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);
 
    int getMaxStep() const;
 
    bool hasBooleanProperty(int ireg, EGS_BPType prop) const;
 
    void setBooleanProperty(EGS_BPType prop);
 
    void addBooleanProperty(int bit);
 
    void setBooleanProperty(EGS_BPType prop, int start, int end, int step=1);
 
    void addBooleanProperty(int bit, int start, int end, int step=1);
 
    const string &getType() const;
 
    EGS_Float getRelativeRho(int ireg) const;
 
    void setRelativeRho(int start, int end, EGS_Float rho);
 
    void setRelativeRho(EGS_Input *);
 
    EGS_Float getBScaling(int ireg) const;
 
    void setBScaling(int start, int end, EGS_Float bf);
 
    void setBScaling(EGS_Input *);
 
    void getLabelRegions(const string &str, vector<int> &regs);
 
    void getNextGeom(EGS_RandomGenerator *rndm);
 
    void updatePosition(EGS_Float time);
 
    void containsDynamic(bool &hasdynamic);
 
protected:
    EGS_BaseGeometry *g;   
    string type;           
    EGS_AffineTransform T; 
    vector<EGS_ControlPoint> cpts;  
    int ncpts;             
    EGS_Float ptime;       
 
    void setMedia(EGS_Input *inp, int, const int *);
 
    int getCoordGeom(EGS_Float rand, EGS_ControlPoint &gipt);
 
    void buildDynamicGeometry(EGS_BaseGeometry *g, EGS_Input *dyninp);
};
 
#endif