CPULSSolver.h

Go to the documentation of this file.

#ifndef CPULSSOLVER_H_
#define CPULSSOLVER_H_

#ifdef __cplusplus
#define _USE_MATH_DEFINES
#include "CPUSolver.h"
#include <math.h>
#include <omp.h>
#include <stdlib.h>
#endif


#define _scalar_flux_xyz(r,e,x) (_scalar_flux_xyz[(r)*_num_groups*3 + (x)*_num_groups + (e)])

#define _reduced_sources_xyz(r,e,x) (_reduced_sources_xyz[(r)*_num_groups*3 + (x)*_num_groups + (e)])

#define _stabilizing_flux_xyz(r,e,x) (_stabilizing_flux_xyz[(r)*_num_groups*3 + (e)*3 + (x)])

#define _fixed_sources_xyz(r,e,i) (_fixed_sources_xyz[(r)*_num_groups + (e)][i])

class CPULSSolver : public CPUSolver {

protected:

  double* _FSR_lin_exp_matrix;

  FP_PRECISION* _FSR_source_constants;

  FP_PRECISION* _scalar_flux_xyz;

  FP_PRECISION* _reduced_sources_xyz;

  FP_PRECISION* _stabilizing_flux_xyz;

  std::vector<std::vector<double> > _fixed_sources_xyz;

  std::map< std::pair<int, int>, std::vector<double> > _fix_src_xyz_FSR_map;

  std::map< std::pair<Cell*, int>, std::vector<double> > _fix_src_xyz_cell_map;

  bool _stabilize_moments;

  bool _fixed_source_moments_on;

public:
  CPULSSolver(TrackGenerator* track_generator=NULL);
  virtual ~CPULSSolver();

  /* Initialization routines */
  void initializeFluxArrays();
  void initializeSourceArrays();
  void initializeCmfd();
  void initializeExpEvaluators();
  void initializeFSRs();

  /* Routines to handle fixed source moments */
  void initializeFixedSources();
  void setFixedSourceMomentsByCell(Cell* cell, int group, double source_x,
                                   double source_y, double source_z);
  void setFixedSourceMomentByFSR(long fsr_id, int group, double source_x,
                                 double source_y, double source_z);

  /* Worker routines */
  void flattenFSRFluxes(FP_PRECISION value);
  double normalizeFluxes();
  void computeFSRSources(int iteration);
  void tallyLSScalarFlux(segment* curr_segment, int azim_index,
                                    int polar_index,
                                    FP_PRECISION* fsr_flux,
                                    FP_PRECISION* fsr_flux_x,
                                    FP_PRECISION* fsr_flux_y,
                                    FP_PRECISION* fsr_flux_z,
                                    float* track_flux,
                                    FP_PRECISION direction[3]);
  void accumulateLinearFluxContribution(long fsr_id, FP_PRECISION weight,
                                        FP_PRECISION* fsr_flux);
  void addSourceToScalarFlux();

  /* Transport stabilization routines */
  void computeStabilizingFlux();
  void stabilizeFlux();
  void checkLimitXS(int iteration);

  /* Routines to handle constant part of linear source */
  void initializeLinearSourceConstants();
  double* getLinearExpansionCoeffsBuffer();
  FP_PRECISION* getSourceConstantsBuffer();

  /* Getter routine */
  FP_PRECISION getFluxByCoords(LocalCoords* coords, int group);
};


#endif /* CPULSSOLVER_H_ */