egs_particle_track.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ particle tracks 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:          Georgi Gerganov, 2009
#
#  Contributors:    Iwan Kawrakow
#
###############################################################################
*/


#ifndef EGS_PARTICLE_TRACK_
#define EGS_PARTICLE_TRACK_

#include "egs_vector.h"
#include "egs_config1.h"
#include "egs_functions.h"

#include <fstream>
using namespace std;

class EGS_EXPORT EGS_ParticleTrack {

public:

    struct Vertex {
        EGS_Vector x;   
        EGS_Float e;    

        Vertex() : x(0,0,0), e(0) {};
        Vertex(EGS_Float px, EGS_Float py, EGS_Float pz) {
            x.x = px;
            x.y = py;
            x.z = pz;
            e = 1;
        };
        Vertex(EGS_Float px, EGS_Float py, EGS_Float pz, EGS_Float pe) {
            x.x = px;
            x.y = py;
            x.z = pz;
            e = pe;
        };
        Vertex(const EGS_Vector &px, EGS_Float pe) : x(px), e(pe) {};
    };

    struct ParticleInfo {
        EGS_I32 q;      
        ParticleInfo(EGS_I32 pq) {
            q = pq;
        };
        ~ParticleInfo() { };
    };

    EGS_ParticleTrack() : m_pInfo(NULL), m_size(16), m_nVertices(0) {
        m_track = new Vertex* [m_size];
    }

    ~EGS_ParticleTrack() {
        clearTrack();
        if (m_track) {
            delete [] m_track;
        }
        m_track = NULL;
    };

    void clearTrack();

    int writeTrack(ofstream *trsp);

    void addVertex(Vertex *x);

    Vertex *getVertex(int v);

    int getNumVertices() {
        return m_nVertices;
    };

    void setParticleInfo(ParticleInfo *p) {
        m_pInfo = p;
    };

    ParticleInfo *getParticleInfo() {
        return m_pInfo;
    };

protected:

    void grow();

    ParticleInfo    *m_pInfo;       

    int             m_size;         
    int             m_nVertices;    
    Vertex          **m_track;      
};

class EGS_EXPORT EGS_ParticleTrackContainer {

public:

    EGS_ParticleTrackContainer() : m_nEvents(0), m_nTracks(0),
        m_totalTracks(0), m_stackMap(NULL), m_isScoring(NULL), m_bufferSize(0),
        m_buffer(NULL), m_trspFile(NULL) {};

    EGS_ParticleTrackContainer(const char *fname, int buf_size) : m_nEvents(0),
        m_nTracks(0), m_totalTracks(0), m_isScoring(NULL), m_bufferSize(0), m_buffer(0),
        m_trspFile(NULL) {
        m_bufferSize = buf_size;

        // initialize the arrays
        m_buffer = new EGS_ParticleTrack* [m_bufferSize];
        m_stackMap = new int [m_bufferSize];
        m_isScoring = new bool [m_bufferSize];
        for (int i = 0; i < m_bufferSize; ++i) {
            m_buffer[i] = new EGS_ParticleTrack();
            m_stackMap[i] = -1;
            m_isScoring[i] = false;
        }

        // open output file and write header
        m_trspFilename = string(fname);
        m_trspFile = new ofstream(m_trspFilename.c_str(), ios::binary);
        int dummy = 0;
        // at the end this will be replaced with the number of recorded tracks
        m_trspFile->write((char *)&dummy, sizeof(int));
    };

    ~EGS_ParticleTrackContainer() {
        // if any particles are left in memory -> flush them to the file
        if (m_nTracks > 0) {
            flushBuffer();
        }

        if (m_buffer) {
            for (int i = 0; i < m_bufferSize; i++) {
                if (m_buffer[i]) {
                    delete m_buffer[i];
                }
                m_buffer[i] = NULL;
            }
            delete [] m_buffer;
            m_buffer = NULL;
        }
        if (m_stackMap) {
            delete [] m_stackMap;
        }
        if (m_isScoring) {
            delete [] m_isScoring;
        }
        if (m_trspFile) {
            delete m_trspFile;
        }
        m_trspFile = NULL;
    };

    void setEvents(int e) {
        m_nEvents = e;
    }

    int getEvents() {
        return m_nEvents;
    }

    int getCurrentNumVertices() {
        return (m_nTracks > 0) ? m_buffer[m_nTracks-1]->getNumVertices() : 0;
    };

    void addVertex(EGS_ParticleTrack::Vertex *x);

    void addVertex(int stackIndex, EGS_ParticleTrack::Vertex *x);

    EGS_ParticleTrack::Vertex *getTrackVertex(int tr, int v);

    bool isScoringParticle() {
        return m_isScoring[m_nTracks-1];
    }

    bool isScoringParticle(int stackIndex) {
        if (m_stackMap[stackIndex] < 0) {
            return false;
        }
        return m_isScoring[m_stackMap[stackIndex]];
    }

    void stopScoringParticle() {
        m_isScoring[m_nTracks-1] = false;
    }

    void stopScoringParticle(int stackIndex) {
        if (m_stackMap[stackIndex] >= 0) {
            m_isScoring[m_stackMap[stackIndex]] = false;
        }
        m_stackMap[stackIndex] = -1;
    }

    void startNewTrack();

    void startNewTrack(int stackIndex);

    void startNewTrack(EGS_ParticleTrack::ParticleInfo *p);

    void setParticleInfo(int stackIndex, EGS_ParticleTrack::ParticleInfo *p) {
        if (m_stackMap[stackIndex] >= 0) {
            m_buffer[m_stackMap[stackIndex]]->setParticleInfo(p);
        }
    }

    void setCurrentParticleInfo(EGS_ParticleTrack::ParticleInfo *p) {
        m_buffer[m_nTracks-1]->setParticleInfo(p);
    }

    int readDataFile(const char *filename);

    void reportResults(bool with_header = true);

protected:

    void flushBuffer();

    void updateHeader();

    int                 m_nEvents;      
    int                 m_nTracks;      
    int                 m_totalTracks;  

    int                 *m_stackMap;    
    bool                *m_isScoring;   
    int                 m_bufferSize;   
    EGS_ParticleTrack   **m_buffer;     
    ofstream            *m_trspFile;    
    string              m_trspFilename; 
};

#endif