Region.h

Go to the documentation of this file.

#ifndef REGION_H_
#define REGION_H_

#ifdef __cplusplus
#include <vector>
#include <math.h>
#include <algorithm>
#include <stdarg.h>
#include <string.h>
#include <utility>
#include "Surface.h"
#include "Material.h"
#endif

#define _USE_MATH_DEFINES

typedef enum regionTypes {
    INFINITE_MEDIUM,
    EQUIVALENT_FUEL,
    EQUIVALENT_MODERATOR,
    BOUNDED_FUEL,
    BOUNDED_MODERATOR,
    BOUNDED_GENERAL
} regionType;



class Region {

protected:
    char* _region_name;
    static int _n;
    int _uid;
    Material* _material;
    regionType _region_type;
    float _buckling_squared;
    float _volume;

public:
    Region(const char* region_name=(char*)"");
    virtual ~Region();
    char* getName();
    int getUid() const;
    Material* getMaterial();
    bool containsIsotope(Isotope* isotope);
    regionType getRegionType();
    float getVolume();
    float getBucklingSquared();

    float getTotalMacroXS(float energy);
    float getTotalMacroXS(int energy_index);
    float getTotalMicroXS(float energy);
    float getTotalMicroXS(int energy_index);
    
    float getElasticMacroXS(float energy);
    float getElasticMacroXS(int energy_index);
    float getElasticMicroXS(float energy);
    float getElasticMicroXS(int energy_index);
    
    float getAbsorptionMacroXS(float energy);
    float getAbsorptionMacroXS(int energy_index);
    float getAbsorptionMicroXS(float energy);
    float getAbsorptionMicroXS(int energy_index);
    
    float getCaptureMacroXS(float energy);
    float getCaptureMacroXS(int energy_index);
    float getCaptureMicroXS(float energy);
    float getCaptureMicroXS(int energy_index);
    
    float getFissionMacroXS(float energy);
    float getFissionMacroXS(int energy_index);
    float getFissionMicroXS(float energy);
    float getFissionMicroXS(int energy_index);
    
    float getTransportMicroXS(float energy);
    float getTransportMicroXS(int energy_index);
    float getTransportMacroXS(float energy);
    float getTransportMacroXS(int energy_index);

    void setMaterial(Material* material);
    void setVolume(float volume);
    void setBucklingSquared(float buckling_squared);

    virtual void collideNeutron(neutron* neutron) =0;
};


class InfiniteMediumRegion: public Region {

public:
    InfiniteMediumRegion(const char* region_name=(char*)"");
    virtual ~InfiniteMediumRegion() { };

    void collideNeutron(neutron* neutron);
};


class EquivalenceRegion: public Region {

private:
    float _fuel_radius;
    float _pitch;
    float _half_width;

    EquivalenceRegion* _other_region;

    float* _prob_ff;
    float* _prob_mf;
    float* _prob_energies;
    int _num_prob;
    float _start_lethargy;
    float _end_lethargy;
    float _delta_lethargy;

public:
    EquivalenceRegion(const char* region_name=(char*)"");
    virtual ~EquivalenceRegion() { };
    float getFuelPinRadius();
    float getPinCellPitch();
    int getEnergyGridIndex(float lethargy);
    bool isFuel();
    bool isModerator();

    void setFirstFlightCollProb(float* prob_ff, float* prob_mf, 
                float* prob_energies, int num_prob);
    void setOtherRegion(EquivalenceRegion* region);
    void setFuelPinRadius(float radius);
    void setPinCellPitch(float pitch);

    float computeFuelFuelCollsionProb(neutron* neutron);
    float computeModeratorFuelCollisionProb(neutron* neutron);
    void collideNeutron(neutron* neutron);
};


class EquivalenceFuelRegion: public EquivalenceRegion {

public:
    EquivalenceFuelRegion(const char* region_name=(char*)"");
    ~EquivalenceFuelRegion() { };
};


class EquivalenceModeratorRegion: public EquivalenceRegion {

public:
    EquivalenceModeratorRegion(const char* region_name=(char*)"");
    ~EquivalenceModeratorRegion() { };
};


class BoundedRegion: public Region {

private:
    std::vector< std::pair<int, Surface*> > _surfaces;

public:
    BoundedRegion(const char* region_name=(char*)"");
    virtual ~BoundedRegion() { };
    void addBoundingSurface(int halfspace, Surface* surface);
    void removeBoundingSurface(int halfspace, Surface* surface);

    bool contains(neutron* neutron);
    bool contains(float x, float y, float z);
    bool onBoundary(neutron* neutron);
    float computeParametrizedDistance(neutron* neutron);

    void collideNeutron(neutron* neutron);
};




class BoundedFuelRegion: public BoundedRegion {

public:
    BoundedFuelRegion(const char* region_name=(char*)"");
    ~BoundedFuelRegion() { };

    void ringify(int num_rings);
};


class BoundedModeratorRegion: public BoundedRegion {

public:
    BoundedModeratorRegion(const char* region_name=(char*)"");
    ~BoundedModeratorRegion() { };

    void ringify(int num_rings);
};


class BoundedGeneralRegion: public BoundedRegion {

public:
    BoundedGeneralRegion(const char* region_name=(char*)"");
    ~BoundedGeneralRegion() { };
};

#endif /* REGION_H_ */