TrackGenerator.h

Go to the documentation of this file.

#ifndef TRACKGENERATOR_H_
#define TRACKGENERATOR_H_

#ifdef __cplusplus
#define _USE_MATH_DEFINES
#ifdef SWIG
#include "Python.h"
#endif
#include "Track.h"
#include "Geometry.h"
#include "MOCKernel.h"
#include "segmentation_type.h"
#include <iostream>
#include <fstream>
#include <sstream>
#include <unistd.h>
#include <omp.h>
#endif


class TrackGenerator {

protected:

  int _num_threads;

  int _num_azim;

  double _azim_spacing;

  int _num_2D_tracks;

  int* _num_x;

  int* _num_y;

  long* _tracks_per_azim;

  Track** _tracks_2D;

  Track** _tracks_2D_array;

  Geometry* _geometry;

  bool _use_input_file;

  std::string _tracks_filename;

  omp_lock_t* _FSR_locks;

  bool _contains_2D_tracks;

  bool _contains_2D_segments;

  Quadrature* _quadrature;

  double _z_coord;

  bool _periodic;

  segmentationType _segment_formation;

  FP_PRECISION _max_optical_length;

  int _max_num_segments;

  bool _dump_segments;

  bool _segments_centered;

  FP_PRECISION* _FSR_volumes;

  Timer* _timer;

  double _x_min;
  double _y_min;
  double _z_min;
  double _x_max;
  double _y_max;
  double _z_max;

  virtual void initializeTracks();
  void initializeTrackReflections();
  virtual void segmentize();
  virtual void setContainsSegments(bool contains_segments);
  virtual void allocateTemporarySegments();
  virtual void resetStatus();
  virtual void initializeDefaultQuadrature();
  virtual void writeExtrudedFSRInfo(FILE* out);
  virtual void readExtrudedFSRInfo(FILE* in);
  virtual std::string getTestFilename(std::string directory);

public:

  TrackGenerator(Geometry* geometry, int num_azim, double azim_spacing);
  virtual ~TrackGenerator();

  /* Get parameters */
  int getNumAzim();
  double getDesiredAzimSpacing();
  Geometry* getGeometry();
  virtual long getNumTracks();
  virtual long getNumSegments();
  long getNum2DTracks();
  long getNum2DSegments();
  void countSegments();
  bool getPeriodic();
  Track** get2DTracksArray();
  Track** getTracksArray();
  Track** get2DTracks();
  FP_PRECISION getMaxOpticalLength();
  int getMaxNumSegments();
  int getNumThreads();
  int getNumX(int azim);
  int getNumY(int azim);
  void exportFSRVolumes(double* out_volumes, int num_fsrs);
  void initializeVolumes();
  void initializeFSRVolumesBuffer();
  FP_PRECISION* getFSRVolumesBuffer();
  FP_PRECISION* getFSRVolumes();
  FP_PRECISION getFSRVolume(long fsr_id);
  double getZCoord();
  Quadrature* getQuadrature();
  FP_PRECISION retrieveMaxOpticalLength();
  omp_lock_t* getFSRLocks();
  segmentationType getSegmentFormation();
  virtual bool containsTracks();
  virtual bool containsSegments();
  int get2DTrackID(int a, int x);
  long* getTracksPerAzim();

  /* Set parameters */
  void setNumThreads(int num_threads);
  void setNumAzim(int num_azim);
  void setDesiredAzimSpacing(double spacing);
  void setGeometry(Geometry* geometry);
  void setZCoord(double z_coord);
  void setQuadrature(Quadrature* quadrature);
  void setMaxOpticalLength(FP_PRECISION tau);
  void setMaxNumSegments(int max_num_segments);
  void setDumpSegments(bool dump_segments);

  /* Worker functions */
  virtual void retrieveTrackCoords(double* coords, long num_tracks);
  void retrieve2DTrackCoords(double* coords, long num_tracks);
  virtual void retrieveSegmentCoords(double* coords, long num_segments);
  void retrieve2DSegmentCoords(double* coords, long num_segments);
  void generateFSRCentroids(FP_PRECISION* FSR_volumes);
  void generateTracks();
  void splitSegments(FP_PRECISION max_optical_length);
  double leastCommonMultiple(double a, double b);
  void dumpSegmentsToFile();
  bool readSegmentsFromFile();
  void initializeTrackFileDirectory();
  void initializeTracksArray();
  virtual void checkBoundaryConditions();

  /* Log functions */
  void printTimerReport(bool mpi_reduce);
  void printMemoryReport();
};


#endif /* TRACKGENERATOR_H_ */