/Users/marc/Developer/EGSnrc/HEN_HOUSE/user_codes/egs_brachy/egs_brachy/phantom.h

Go to the documentation of this file.

/*
################################################################################
#
#  egs_brachy phantom.h
#  Copyright (C) 2016 Rowan Thomson, Dave Rogers, Randle Taylor, and Marc
#  Chamberland
#
#  This file is part of egs_brachy
#
#  egs_brachy 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.
#
#  egs_brachy 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:
#  <http://www.gnu.org/licenses/>.
#
################################################################################
#
#  When egs_brachy is used for publications, please cite our paper:
#  M. J. P. Chamberland, R. E. P. Taylor, D. W. O. Rogers, and R. M. Thomson,
#  egs brachy: a versatile and fast Monte Carlo code for brachytherapy,
#  Phys. Med. Biol. 61, 8214-8231 (2016).
#
################################################################################
#
#  Author:        Randle Taylor, 2016
#
#  Contributors:  Marc Chamberland
#                 Dave Rogers
#                 Rowan Thomson
#
################################################################################
*/
 
#ifndef EB_PHANTOM_
#define EB_PHANTOM_
 
#include <map>
#include <set>
#include "egs_scoring.h"
#include "egs_application.h"
#include "egs_interface2.h"
#include "pubsub.h"
 
struct RegionResult;
 
class EB_Phantom : public Subscriber {
 
private:
 
    const static string autovol_phantom_geom_types[];
    const static string threeddose_geom_types[];
 
    EGS_Application *app;  
    EGS_ScoringArray *tlen_score; 
    EGS_ScoringArray *edep_score; 
    EGS_ScoringArray *prim_score; 
    EGS_ScoringArray *sscat_score; 
 
    EGS_ScoringArray *mscat_score; 
 
    int nsources;
    EGS_Float dose_scale;
 
    EGS_Float total_radiant_e;
    EGS_I64 cur_history;
    EGS_Float effective_histories;
 
    Publisher *publisher;
 
    std::map<int, double> corrected_volumes; 
    std::map<int, double> volume_uncertainty;
 
    void outputDoseStats(EGS_ScoringArray *score, string type);
 
    void outputTopDoses(int top_n, vector<RegionResult> region_results);
 
    void output3ddoseResults(string);
 
    void output3DDoses(ostream &out, EGS_ScoringArray *score, string type);
 
    void output3DBounds(ostream &out);
 
    void outputEGSPhant(string);
 
    void writeEGSPhant(ostream &);
 
    string medIndex(int medium);
 
    vector<RegionResult> getRegionResults();
 
    void getScoringArrays(vector<EGS_ScoringArray *> &scores, vector<string> &types, vector<string> &descriptions);
 
    void getEGSdatScoringArrays(vector<EGS_ScoringArray *> &scores);
 
 
public:
 
    enum GeomDirections {
        XDIR, 
        YDIR, 
        ZDIR  
    };
 
    EB_Phantom(EGS_Application *, EGS_BaseGeometry *, set<int> global_regions, int nsource, Publisher *publisher);
 
    ~EB_Phantom() {
 
        if (tlen_score) {
            delete tlen_score;
        }
        if (edep_score) {
            delete edep_score;
        }
        if (prim_score) {
            delete prim_score;
        }
        if (sscat_score) {
            delete sscat_score;
        }
        if (mscat_score) {
            delete mscat_score;
        }
 
    };
 
    static bool needsUserVolumes(const string &geom_type);
 
    static bool canWrite3ddose(const string &geom_type);
 
    void scoreTlen(int ir, EGS_Float dose, EGS_Particle *p);
 
    void scoreEdep(int ir, EGS_Float dose);
 
    void getCurrentScore(int ireg, double &sum, double &sum2);
 
    double getTlenNorm(int ireg);
 
    void setDoseScale(EGS_Float);
 
    void update(EB_Message message, void *data);
 
    bool hasVolCor(int ireg);
 
    EGS_Float getCorrectedVolume(int ireg);
 
    EGS_Float getVolumeUncertainty(int ireg);
 
    EGS_Float getUncorrectedVolume(int ireg);
 
 
    vector<int> getRegionsWithCorrections();
 
    void setCorrectedVolume(int ir, double fraction, double unc=0);
 
    void enableTLenScoring();
 
    void enableInteractionScoring();
 
    void enableScatterScoring();
 
 
    void setHistory(EGS_I64 current_case);
 
    void setEffectiveHistories(EGS_Float current_case);
 
    EGS_Float avgVoxelVol();
 
    void outputVoxelInfo(string format);
 
    void writeVoxelInfo(ostream &);
 
    void outputVolumeCorrection(string format);
 
    void writeVolumeCorrection(ostream &);
 
    void outputResults(int top_n=20, string output_3ddose="text", string output_egsphant="text",
                       string output_voxinfo="text", string output_volcor="text");
 
    bool globalRegIsInPhant(int global_reg) {
        return (global_reg_start <= global_reg) && (global_reg <= global_reg_stop);
    }
 
    int globalToLocal(int global_reg) {
        if ((global_reg_start <= global_reg) && (global_reg <= global_reg_stop)) {
            return global_reg - global_reg_start;
        }
 
        return -1;
    }
 
 
 
    int outputData(ostream *ofile);
    int readData(istream *ifile);
    void resetCounter();
    int addState(istream &ifile);
 
    EGS_Float getRealRho(int ireg);
 
    EGS_Float getRealMass(int ireg);
 
    EGS_Float getUncorrectedMass(int ireg);
 
    void getResult(EGS_ScoringArray *, int ireg, string type, EGS_Float &r, EGS_Float &dr);
 
 
    EGS_BaseGeometry *geometry;
 
    set<int> global_regions;
 
    int global_reg_start; 
    int global_reg_stop; 
 
    bool needs_user_geoms; 
    bool can_write_3ddose; 
 
};
 
#endif