TrackGenerator3D.h

Go to the documentation of this file.

#ifndef TRACKGENERATOR3D_H_
#define TRACKGENERATOR3D_H_

#include "TrackGenerator.h"
#include "Track3D.h"


struct TrackChainIndexes {

  int _azim;

  int _x;

  int _polar;

  int _lz;

  int _link;

  TrackChainIndexes() {
    _azim  = -1;
    _x = -1;
    _polar = -1;
    _lz    = -1;
    _link = -1;
  }
};


struct TrackStackIndexes {

  int _azim;

  int _xy;

  int _polar;

  int _z;

  TrackStackIndexes() {
    _azim  = -1;
    _xy    = -1;
    _polar = -1;
    _z     = -1;
  }
};


class TrackGenerator3D : public TrackGenerator {

private:

  int _num_polar;

  double _z_spacing;

  Track**** _tracks_2D_chains;

  int*** _tracks_per_stack;

  long*** _cum_tracks_per_stack;

  long** _cum_tracks_per_xy;

  int*** _first_lz_of_stack;

  int _num_3D_tracks;

  int** _num_z;
  int** _num_l;

  /* Arrays for the spacing along each axis */
  double** _dz_eff;
  double** _dl_eff;

  Track3D**** _tracks_3D;

  std::vector<double> _segmentation_heights;

  std::vector<double> _global_z_mesh;

  int _num_seg_matrix_rows;
  int _num_seg_matrix_columns;

  std::vector<segment*> _temporary_segments;
  bool _contains_temporary_segments;

  std::vector<Track3D*> _temporary_3D_tracks;
  std::vector<Track**> _temporary_tracks_array;
  bool _contains_temporary_tracks;

  int _max_num_tracks_per_stack;

  bool _contains_3D_tracks;
  bool _contains_3D_segments;
  bool _contains_global_z_mesh;
  bool _contains_segmentation_heights;

  void initializeTracks();
  void initialize2DTrackChains();
  void recalibrateTracksToOrigin();
  void segmentize();
  void setContainsSegments(bool contains_segments);
  void allocateTemporarySegments();
  void allocateTemporaryTracks();
  void resetStatus();
  void initializeDefaultQuadrature();
  std::string getTestFilename(std::string directory);
  void getCycleTrackData(TrackChainIndexes* tcis, int num_cycles,
                         bool save_tracks);

  void segmentizeExtruded();
  void set3DTrackData(TrackChainIndexes* tci, Track3D* track,
                      bool create_arrays, bool save_tracks);
  double getLStart(TrackChainIndexes* tci);
  int getFirst2DTrackLinkIndex(TrackChainIndexes* tci, Track3D* track_3D);

  void writeExtrudedFSRInfo(FILE* out);
  void readExtrudedFSRInfo(FILE* in);

public:

  TrackGenerator3D(Geometry* geometry, int num_azim, int num_polar,
                   double azim_spacing, double z_spacing);
  virtual ~TrackGenerator3D();

  /* Get parameters */
  int getNumPolar();
  double getDesiredZSpacing();
  long getNumTracks();
  long getNumSegments();
  long getNum3DTracks();
  long getNum3DSegments();
  Track3D**** get3DTracks();
  double getZSpacing(int azim, int polar);
  int getNumRows();
  int getNumColumns();
  segment* getTemporarySegments(int thread_id);
  Track3D* getTemporary3DTracks(int thread_id);
  Track** getTemporaryTracksArray(int thread_id);
  int getNumZ(int azim, int polar);
  int getNumL(int azim, int polar);
  int*** getTracksPerStack();
  int getMaxNumTracksPerStack();
  bool containsTracks();
  bool containsSegments();
  bool containsTemporaryTracks();
  long get3DTrackID(TrackStackIndexes* tsi);
  void convertTCItoTSI(TrackChainIndexes* tci, TrackStackIndexes* tsi);
  void convertTSItoTCI(TrackStackIndexes* tsi, TrackChainIndexes* tci);
  int getLinkIndex(TrackChainIndexes* tci);
  int getNum3DTrackChainLinks(TrackChainIndexes* tci);
  void getTSIByIndex(long id, TrackStackIndexes* tsi);

  void getTrackOTF(Track3D* track, TrackStackIndexes* tsi);

  /* Set parameters */
  void setNumPolar(int num_polar);
  void setDesiredZSpacing(double spacing);
  void setSegmentFormation(segmentationType segmentation_type);
  void setSegmentationZones(std::vector<double> z_mesh);
  void setLinkingTracks(TrackStackIndexes* tsi, TrackChainIndexes* tci,
                        bool outgoing, Track3D* track);
  void setLinkIndex(TrackChainIndexes* tci, TrackStackIndexes* tsi);
  void useGlobalZMesh();

  /* Worker functions */
  void retrieveTrackCoords(double* coords, long num_tracks);
  void retrieve3DTrackCoords(double* coords, long num_tracks);
  void retrieveGlobalZMesh(double*& z_mesh, int& num_fsrs);
  void retrieveSingle3DTrackCoords(double coords[6], long track_id);
  void retrieveSegmentCoords(double* coords, long num_segments);
  void retrieve3DSegmentCoords(double* coords, long num_segments);
  void create3DTracksArrays();
  void checkBoundaryConditions();
};

#endif /* TRACKGENERATOR3D_H_ */