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
#                   Reid Townson
#                   Alexandre Demelo
#
###############################################################################
*/
 
 
#ifndef EGS_PARTICLE_TRACK_
#define EGS_PARTICLE_TRACK_
 
#include "egs_vector.h"
#include "egs_config1.h"
#include "egs_functions.h"
 
#include <fstream>
#include <cstring>
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, bool incltime);
 
    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;
    };
 
    void setTimeIndex(EGS_Float time) {
        time_index = time;
    };
 
    EGS_Float getTimeIndex() {
        return time_index;
    };
 
protected:
 
    void grow();
 
    ParticleInfo    *m_pInfo;       
    EGS_Float       time_index;
 
    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, bool time_bool) : 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;
        strncpy(head_inctime, "include time index=", 20);
 
        // Initialize the arrays. The incltime variable set from the time_bool
        // passed from the constructor (track scoring object gets incltime from
        // input file and calls and passes)
        incltime = time_bool;
        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);
 
        // Now the file starts with whether or not the time index is included in the data per track
        // E.g. "include time index=1" for true
        m_trspFile->write(head_inctime, sizeof(head_inctime));
        m_trspFile->write((char *)&incltime, sizeof(bool));
 
        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);
    }
 
    void setCurrentTimeIndex(EGS_Float time) {
        m_buffer[m_nTracks-1]->setTimeIndex(time);
    }
 
    int readDataFile(const char *filename);
 
    void reportResults(bool with_header = true);
 
    void tracksFileSort();
 
protected:
 
    void flushBuffer();
 
    void updateHeader();
 
    bool                incltime;
    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; 
 
    char head_inctime[20];
};
 
#endif