egs_track_scoring.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ particle track scoring object 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:          Iwan Kawrakow, 2009
#
#  Contributors:    Georgi Gerganov
#                   Alexandre Demelo
#
###############################################################################
*/
 
 
#ifndef EGS_TRACK_SCORING_
#define EGS_TRACK_SCORING_
 
#include "egs_ausgab_object.h"
#include "egs_application.h"
#include "egs_particle_track.h"
 
#ifdef WIN32
 
    #ifdef BUILD_TRACK_SCORING_DLL
        #define EGS_TRACK_SCORING_EXPORT __declspec(dllexport)
    #else
        #define EGS_TRACK_SCORING_EXPORT __declspec(dllimport)
    #endif
    #define EGS_TRACK_SCORING_LOCAL
 
#else
 
    #ifdef HAVE_VISIBILITY
        #define EGS_TRACK_SCORING_EXPORT __attribute__ ((visibility ("default")))
        #define EGS_TRACK_SCORING_LOCAL  __attribute__ ((visibility ("hidden")))
    #else
        #define EGS_TRACK_SCORING_EXPORT
        #define EGS_TRACK_SCORING_LOCAL
    #endif
 
#endif
 
class EGS_TRACK_SCORING_EXPORT EGS_TrackScoring : public EGS_AusgabObject {
 
public:
 
    EGS_TrackScoring(const string &Name="", EGS_ObjectFactory *f = 0);
 
    ~EGS_TrackScoring();
 
    int processEvent(EGS_Application::AusgabCall iarg) {
        if (m_score) {
            if (!m_didScore) {
                m_didScore = true;
                ++m_nScore;
            }
            int np = app->Np;
            if (m_pts->isScoringParticle(np)) {
                if (iarg == EGS_Application::AfterTransport) {
                    m_pts->addVertex(np,new EGS_ParticleTrack::Vertex(app->top_p.x,app->top_p.E));
                }
                else if (iarg != EGS_Application::BeforeTransport) {
                    m_pts->stopScoringParticle(np);
                }
            }
            else if (iarg == EGS_Application::BeforeTransport) {
                int q = app->top_p.q;
                EGS_Float timeindex = app->getTimeIndex(); // get current time index from the source (through the application.cpp)
                if ((q ==  0 && m_score_photons) ||
                        (q == -1 && m_score_electrons) ||
                        (q ==  1 && m_score_positrons)) {
                    m_pts->startNewTrack(np);
                    m_pts->setCurrentParticleInfo(new EGS_ParticleTrack::ParticleInfo(q));
                    m_pts->setCurrentTimeIndex(timeindex); // set current time index for the particle track container object
                    m_pts->addVertex(np,new EGS_ParticleTrack::Vertex(app->top_p.x,app->top_p.E));
                }
            }
        }
        return 0;
    };
 
    bool needsCall(EGS_Application::AusgabCall iarg) const {
        return true;
    };
 
    void setApplication(EGS_Application *App);
 
    void reportResults();
 
    void setCurrentCase(EGS_I64 ncase) {
        if (ncase != m_lastCase) {
            m_lastCase = ncase;
            m_didScore = false;
        }
        if (ncase < m_start || ncase > m_stop) {
            m_score = false;
        }
        else {
            m_score = true;
        }
    };
 
    void setScorePhotons(bool score)   {
        m_score_photons = score;
    };
    void setScoreElectrons(bool score) {
        m_score_electrons = score;
    };
    void setScorePositrons(bool score) {
        m_score_positrons = score;
    };
    void setIncludeTime(bool incltime) {
        m_include_time = incltime;
    };
    void setAutoDetectDynamic(bool autoDetectDynamic) {
        m_autoDetectDynamic = autoDetectDynamic;
    };
    void setFirstEvent(EGS_I64 first)  {
        m_start = first;
    };
    void setLastEvent(EGS_I64 last)    {
        m_stop = last;
    };
    void setBufferSize(int size)       {
        m_bufSize = size;
    };
    void setFileNameExtra(const string &extra) {
        m_fnExtra = extra;
    };
 
protected:
 
    EGS_ParticleTrackContainer  *m_pts;               
 
    EGS_I64                     m_start;              
    EGS_I64                     m_stop;               
    EGS_I64                     m_lastCase;           
    EGS_I64                     m_nScore;             
 
    int                         m_bufSize;            
 
    bool                        m_score;              
    bool                        m_didScore;           
 
    bool                        m_score_photons;      
    bool                        m_score_electrons;    
    bool                        m_score_positrons;    
    bool                        m_include_time;       
    bool                        m_autoDetectDynamic;  
 
    string                      m_fnExtra;            
 
};
 
#endif