physics_engine.h

#ifndef PHYSICSENGINE_H
#define PHYSICSENGINE_H
 
#include "photon.h"
#include "computational_domain.h"
#include "probability_dist.h"
#include "interaction_data.h"
#include "interpolators.h"
#include "photon_interactions.h"
#include "volume_tally.h"
#include "voxel.h"
#include "surface_tally.h"
#include <cmath>
#include <utility>
 
namespace PhysicsEngineHelpers {
    bool areCollinearAndSameDirection(const Eigen::Vector3d& vec1, const Eigen::Vector3d& vec2);
}
 
 
class PhysicsEngine {
public:
 
    PhysicsEngine(ComputationalDomain& comp_domain, InteractionData& interaction_data);
 
    void transportPhoton(Photon& photon);
 
    void transportPhotonOneStep(Photon& photon, std::vector<TempSurfaceTallyData>& temp_surface_tally_data_per_photon,
                                std::vector<TempVolumeTallyData>& temp_volume_tally_data_per_photon,
                                std::vector<TempVoxelData>& temp_voxel_data_per_photon);
 
    void setInteractionType(Photon& photon, Material& material, double total_cross_section);
 
    void addVolumeTallies(std::vector<std::unique_ptr<VolumeTally>>&& volume_tallies);
 
    void addSurfaceTallies(std::vector<std::unique_ptr<SurfaceTally>>&& surface_tallies);
 
    void initializeVoxelData();
 
 
    std::vector<VolumeQuantityContainer> getVolumeQuantityContainers();
 
    std::vector<SurfaceQuantityContainer> getSurfaceQuantityContainers();
 
    void addVoxelDataToComputationalDomain();
 
    static void processPhotonOutsideVoxelGrid(Photon& photon);
private:
    ComputationalDomain& comp_domain_;
    ProbabilityDist::Uniform uniform_dist_;
    InteractionData& interaction_data_;
    std::vector<std::vector<std::unique_ptr<VolumeTally>>> thread_local_volume_tallies_;
    std::vector<std::vector<std::unique_ptr<SurfaceTally>>> thread_local_surface_tallies_;
    std::vector<std::vector<TempVoxelData>> thread_local_voxel_data_;
    std::shared_ptr<PhotoelectricEffect> photoelectric_effect_;
    std::shared_ptr<IncoherentScattering> incoherent_scattering_;
    std::shared_ptr<CoherentScattering> coherent_scattering_;
 
    double getFreePath(double max_cross_section);
 
    bool isDeltaScatter(double cross_section, double max_cross_section);
 
    void updateTempTallyPerPhoton(std::vector<TempSurfaceTallyData>& temp_surface_tally_data_per_photon,
                                  std::vector<TempVolumeTallyData>& temp_volume_tally_data_per_photon,
                                    TempSurfaceTallyData& temp_surface_tally_data, TempVolumeTallyData& temp_volume_tally_data);
 
    void processTallies(std::vector<TempSurfaceTallyData>& temp_surface_tally_data_per_photon,
                                       std::vector<TempVolumeTallyData>& temp_volume_tally_data_per_photon,
                                       std::vector<TempVoxelData>& temp_voxel_data_per_photon);
};
 
#endif