MOCKernel.h

Go to the documentation of this file.

#ifndef MOCKERNEL_H_
#define MOCKERNEL_H_

#ifdef SWIG
#include "Python.h"
#endif
#include "Track.h"
#include "Track3D.h"
#include "Geometry.h"
#include "Quadrature.h"


/* Forward declaration of TrackGenerator */
class TrackGenerator;

/* Forward declaration of CPUSolver */
class CPUSolver;

class MOCKernel {

protected:

  int _count;

  FP_PRECISION _max_tau;

  int _num_groups;

public:

  MOCKernel(TrackGenerator* track_generator);
  virtual ~MOCKernel();

  /* Function to get the current segment count */
  int getCount();

  /* Sets the max optical path length to a different value */
  void setMaxOpticalLength(FP_PRECISION max_tau);

  /* Prepare MOCKernel for handling a new track */
  virtual void newTrack(Track* track);

  /* Executing function describes kernel behavior */
  virtual void execute(FP_PRECISION length, Material* mat, long fsr_id,
                       int track_idx, int cmfd_surface_fwd,
                       int cmfd_surface_bwd, FP_PRECISION x_start, FP_PRECISION y_start,
                       FP_PRECISION z_start, FP_PRECISION phi, FP_PRECISION theta)=0;

};


class CounterKernel: public MOCKernel {

public:
  CounterKernel(TrackGenerator* track_generator);
  void execute(FP_PRECISION length, Material* mat, long fsr_id,
               int track_idx, int cmfd_surface_fwd, int cmfd_surface_bwd,
               FP_PRECISION x_start, FP_PRECISION y_start, FP_PRECISION z_start,
               FP_PRECISION phi, FP_PRECISION theta);
};


class VolumeKernel: public MOCKernel {

private:

  omp_lock_t* _FSR_locks;

  FP_PRECISION* _FSR_volumes;

  FP_PRECISION _weight;

  Quadrature* _quadrature;

public:

  VolumeKernel(TrackGenerator* track_generator);
  void newTrack(Track* track);
  void execute(FP_PRECISION length, Material* mat, long fsr_id,
               int track_idx, int cmfd_surface_fwd, int cmfd_surface_bwd,
               FP_PRECISION x_start, FP_PRECISION y_start, FP_PRECISION z_start,
               FP_PRECISION phi, FP_PRECISION theta);
};


class SegmentationKernel: public MOCKernel {

private:

  segment* _segments;

public:
  SegmentationKernel(TrackGenerator* track_generator);
  void execute(FP_PRECISION length, Material* mat, long fsr_id,
               int track_idx, int cmfd_surface_fwd, int cmfd_surface_bwd,
               FP_PRECISION x_start, FP_PRECISION y_start, FP_PRECISION z_start,
               FP_PRECISION phi, FP_PRECISION theta);
};

class TransportKernel: public MOCKernel {
private:

  CPUSolver* _cpu_solver;

  TrackGenerator* _track_generator;

  FP_PRECISION* _thread_fsr_flux;

  int _azim_index;

  int _xy_index;

  int _polar_index;

  int _track_id;

  bool _direction;

  int _min_track_idx;
  int _max_track_idx;

public:
  TransportKernel(TrackGenerator* track_generator);
  virtual ~TransportKernel();
  void newTrack(Track* track);
  void setCPUSolver(CPUSolver* cpu_solver);
  void setTrackFlux(FP_PRECISION* fwd_flux, FP_PRECISION* bwd_flux,
                    int track_id);
  void setTrackIndexes(int azim_index, int polar_index);
  void setDirection(bool direction);
  bool getDirection();
  void execute(FP_PRECISION length, Material* mat, long fsr_id,
               int track_idx, int cmfd_surface_fwd, int cmfd_surface_bwd,
               FP_PRECISION x_start, FP_PRECISION y_start, FP_PRECISION z_start,
               FP_PRECISION phi, FP_PRECISION theta);
  void post();
};


#endif /* MOCKERNEL_H_ */