egs_track_scoring.cpp

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ particle track scoring object
#  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, 2009
#
#  Contributors:    Georgi Gerganov
#                   Alexandre Demelo
#                   Hannah Gallop
#
###############################################################################
*/
 
 
#include "egs_track_scoring.h"
#include "egs_input.h"
#include "egs_functions.h"
 
static bool EGS_TRACK_SCORING_LOCAL inputSet = false;
 
EGS_TrackScoring::EGS_TrackScoring(const string &Name, EGS_ObjectFactory *f) :
    EGS_AusgabObject(Name,f), m_pts(0), m_start(0), m_stop(1024), m_lastCase(-1),
    m_nScore(0), m_bufSize(16), m_score(false), m_didScore(false),
    m_score_photons(true), m_score_electrons(true), m_score_positrons(true), m_fnExtra(""), m_include_time(false) {
    otype = "EGS_TrackScoring";
}
 
EGS_TrackScoring::~EGS_TrackScoring() {
    if (m_pts) {
        delete m_pts;
    }
}
 
void EGS_TrackScoring::setApplication(EGS_Application *App) {
    EGS_AusgabObject::setApplication(App);
    if (!app) {
        return;
    }
    if (m_pts) {
        delete m_pts;
        m_pts = 0;
    }
    if (m_bufSize < 1) {
        m_bufSize = 1024;
    }
    string fname(app->getOutputFile());
    fname += m_fnExtra;
    if (!egsIsAbsolutePath(fname)) {
        fname = egsJoinPath(app->getAppDir(),fname);
    }
 
    fname += ".ptracks";
 
    // Determine whether a dynamic geometry or source was used
    // Only do this if the user didn't explicitly say whether to include time indices
    if (m_autoDetectDynamic) {
        m_include_time = app->containsDynamic();
    }
 
    // create new particleTrackContainer using the m_include_time boolean which
    // controls time index writting and filetype
    m_pts = new EGS_ParticleTrackContainer(fname.c_str(),m_bufSize,m_include_time);
 
    description = "\nParticle Track Scoring (";
    description += name;
    description += ")\n";
    description += "======================================================\n";
    description += " - Scoring photon tracks       = ";
    description += m_score_photons ? "YES\n" : "NO\n";
    description += " - Scoring electron tracks     = ";
    description += m_score_electrons ? "YES\n" : "NO\n";
    description += " - Scoring positron tracks     = ";
    description += m_score_positrons ? "YES\n" : "NO\n";
    description += " - Include time index          = ";
    description += m_include_time ? "YES\n" : "NO\n";
    description += " - First event to score        = ";
    char buf[32];
    sprintf(buf,"%lld\n",m_start);
    description += buf;
    description += " - Last event to score         = ";
    sprintf(buf,"%lld\n",m_stop);
    description += buf;
    description += " - Track buffer size           = ";
    sprintf(buf,"%d\n",m_bufSize);
    description += buf;
    description += " - Output file name            = ";
    description += fname;
    description += "\n\n";
}
 
void EGS_TrackScoring::reportResults() {
    egsInformation("\nParticle Track Scoring (%s)\n",name.c_str());
    egsInformation("======================================================\n");
    egsInformation("   Total events scored:     %lld\n",m_nScore);
    if (m_pts) {
        m_pts->reportResults(false);
    }
}
 
 
extern "C" {
 
    static void setInputs() {
        inputSet = true;
 
        setBaseAusgabObjectInputs();
 
        ausBlockInput->getSingleInput("library")->setValues({"egs_track_scoring"});
 
        // Format: name, isRequired, description, vector string of allowed values
        ausBlockInput->addSingleInput("score photons", false, "Score photons? Default is yes.", {"yes", "no"});
        ausBlockInput->addSingleInput("score electrons", false, "Score the electrons? Default is yes.", {"yes", "no"});
        ausBlockInput->addSingleInput("score positrons", false, "Score positrons? Default is yes.", {"yes", "no"});
        ausBlockInput->addSingleInput("start scoring", false, "The history at which to start recording tracks. Defaults to 0.");
        ausBlockInput->addSingleInput("stop scoring", false, "The history at which to stop recording tracks. Defaults to 1024.");
        ausBlockInput->addSingleInput("buffer size", false, "The number of tracks to save in a buffer before writing out to a file. Defaults to 1024.");
        ausBlockInput->addSingleInput("file name addition", false, "A string that is appended to the input file name for the .ptracks file");
    }
 
    EGS_TRACK_SCORING_EXPORT string getExample() {
        string example;
        example = {
            R"(
    # Example of egs_track_scoring
    :start ausgab object:
        library = egs_track_scoring
        name = my_score
        score photons = yes
        score electrons = yes
        score positrons = yes
        start scoring = 0
        stop scoring = 1024
    :stop ausgab object:
)"};
        return example;
    }
 
    EGS_TRACK_SCORING_EXPORT shared_ptr<EGS_BlockInput> getInputs() {
        if(!inputSet) {
            setInputs();
        }
        return ausBlockInput;
    }
 
    EGS_TRACK_SCORING_EXPORT EGS_AusgabObject *createAusgabObject(EGS_Input *input,
            EGS_ObjectFactory *f) {
        const static char *func = "createAusgabObject(track_scoring)";
        if (!input) {
            egsWarning("%s: null input?\n",func);
            return 0;
        }
 
        vector<string> sc_options;
        sc_options.push_back("no");
        sc_options.push_back("yes");
        bool scph = input->getInput("score photons",sc_options,true);
        bool scel = input->getInput("score electrons",sc_options,true);
        bool scpo = input->getInput("score positrons",sc_options,true);
        if (!scph && !scel && !scpo) {
            return 0;
        }
 
        // include time index lets the program know whether to write the time
        // index to the tracks file
        // The default is -1 so we know if this input wasn't specified
        bool found = false;
        bool incltime = input->getInput("include time index",sc_options,1,&found);
        // If the user didn't specify whether or not to include time indices
        // check if a dynamic source or geometry is in use
        bool autoDetectDynamic = false;
        if (!found) {
            autoDetectDynamic = true;
        }
 
        EGS_I64 first = 0, last = 1024;
        input->getInput("start scoring",first);
        input->getInput("stop scoring",last);
        int bufSize = 1024;
        input->getInput("buffer size",bufSize);
        string fnExtra;
        input->getInput("file name addition",fnExtra);
        EGS_TrackScoring *result = new EGS_TrackScoring("",f);
        result->setScorePhotons(scph);
        result->setScoreElectrons(scel);
        result->setScorePositrons(scpo);
        result->setIncludeTime(incltime); // incltime boolean is set from aquired input for the trackscoring object (sets m_include_time)
        result->setAutoDetectDynamic(autoDetectDynamic);
        result->setFirstEvent(first);
        result->setLastEvent(last);
        result->setBufferSize(bufSize);
        result->setFileNameExtra(fnExtra);
        result->setName(input);
        return result;
    }
 
}