GenericReactorAssembly.hxx

Go to the documentation of this file.

/*
  This file is part of MURE,
  Copyright (C) 2007-2021 MURE developers.
 
  MURE is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  MURE is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License
  along with MURE.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef _GenericReactorAssembly_HXX
#define _GenericReactorAssembly_HXX
 
#include <vector>
#include <algorithm>
#include <fstream>
#include <string>
 
#include "LatticeCell.hxx"
#include "PinCell.hxx"
#include "Material.hxx"
#include "MCSource.hxx"
 
class Cell;
class Material;
class PinCell;
 
using namespace std;
 
 
 
class GenericReactorAssembly
{
  public:
    GenericReactorAssembly(
        double Pitch,               
        int NRadialZones = 1,           
        int NZLevels = 1,               
        string AssemblyName = "GenericAss" 
    );
    GenericReactorAssembly(const GenericReactorAssembly &m);
    virtual GenericReactorAssembly *Clone() = 0;
    virtual ~GenericReactorAssembly(); 
 
 
    void SetAssemblyDuct(double DuctThickness, Material *DuctMat);
 
    void SetPlenum(double PlenumThickness, Material *UpperPlenumMat, Material *LowerPlenumMat = nullptr);
 
    void SetAssemblyShape(Shape_ptr TheOuterShape, Shape_ptr TheRealShape = Shape_ptr(nullptr));
 
    void AddFuelPin(PinCell *pin, int Ix = 99999, int Iy = 99999, int ZoneNumber = - 1);
 
    void AddGuideTube(PinCell *pin, int Ix, int Iy, int ZoneNumber = - 1);
 
    void AddControlRod(PinCell *pin, int Ix, int Iy, int ZoneNumber = - 1);
    
    bool IsGuideTubes() {return fIsGuideTubes;}     
    bool IsControlRods(){return fIsControlRods;}    
    bool IsPlenum() {return fIsPlenum;}             
    bool IsDuct(){return fIsDuct;}                  
    Cell *GetUpperCellPlenum(){return fCPlenumUp;}  
    Cell *GetLowerCellPlenum(){return fCPlenumDown;}
    Cell *GetDuctCell(){return fCellDuct;}          
    
    vector < double > GetGuideTubeOuterRadius();    
    vector < double > GetControlRodOuterRadius();   
    vector < PinCell *>  GetPinCellOfDifferentShape(string PinType);    
 
 
    int GetNumberOfRadialZones()
    {
        return fRadialZones;   
    }
    int GetNumberOfAxialLevels()
    {
        return fAxialLevels;   
    }
    void AddRadialZone2Mesh(double Radius, int ZoneNum);
    void AddRadialZone2Mesh(int Ix, int Iy, int ZoneNum );
 
    int GetRadialLatticeMeshZone(int x, int y, int z)
    {
        return fRadialMeshZone[x][y];   
    }
 
    vector < Cell *> GetFuelCell(int RadialZoneNumber, int AxialLevelNumber);
 
    vector < PinCell *> &GetPinCellVector(int RadialZoneNumber, int AxialLevelNumber)
    {
        return fPinCellVector[RadialZoneNumber][AxialLevelNumber];   
    }
 
    vector < vector < vector < int > > > GetGlobalLatticeMesh()
    {
        return fMeshLattice;   
    }
 
 
    int GetGlobalLatticeMeshUniverse(int x, int y, int z);
    PinCell *GetGlobalLatticeMeshPin(int x, int y, int z);
    int GetMCXMeshSize()
    {
        return fNx;   
    }
    int GetMCYMeshSize()
    {
        return fNy;   
    }
    int GetMCMeshXmin()
    {
        return fIXmin;   
    }
    int GetMCMeshXmax()
    {
        return fIXmax;   
    }
    int GetMCMeshYmin()
    {
        return fIYmin;   
    }
    int GetMCMeshYmax()
    {
        return fIYmax;   
    }
    int GetMCMeshZmin()
    {
        return fIZmin;   
    }
    int GetMCMeshZmax()
    {
        return fIZmax;   
    }
 
 
 
 
 
    virtual void BuildAssemblyGeometry() = 0;
    Shape_ptr GetAssemblyShape()
    {
        return fSAssemblyZone;   
    }
    bool IsHexagonalAssembly()
    {
        return fIsHexagon;   
    }
 
    double GetPitch()
    {
        return fPitch;   
    }
    double GetWidth()
    {
        return fAssemblyWidth;   
    }
    double GetSide()
    {
        return fAssemblySide;   
    }
    double GetHeight()
    {
        return fAssemblyHeight;   
    }
    double GetAxialLevelHeight()
    {
        return fAxialLevelHeight;   
    }
    double GetPlenumThickness()
    {
        return fPlenumThickness;   
    }
    double GetDuctThickness()
    {
        return fDuctThickness;   
    }
    void Translate(
        double dx,          
        double dy,          
        double dz           
    );
    double GetPrimitiveCellXCenter()
    {
        return fPrimitiveCellXCenter;   
    }
    double GetPrimitiveCellYCenter()
    {
        return fPrimitiveCellYCenter;   
    }
 
    void SetBorderPin(PinCell *pin);
 
    Shape_ptr GetInfiniteAssemblyShape();
    
    void SetSpatialVariable(PinCell *pin, string RadialZoneName, double RadialZoneValue, string ZLevelName, double ZLevelValue);
    
    void SetNumberOfInstance(int N);
    
 
    void SetUniverse(int u = - 1);
    int GetUniverse()
    {
        return fUniverse;   
    }
 
    vector < int >  &GetNumberOfFuelPinsPerZone()
    {
        return fNumberOfFuelPinsPerZone;   
    }
    vector < int >  &GetNumberOfGuideTubesPerZone()
    {
        return fNumberOfGuideTubesPerZone;   
    }
    vector < int >  &GetNumberOfControlRodsPerZone()
    {
        return fNumberOfControlRodsPerZone;   
    }
    vector < int >  &GetNumberOfCoolantPinsPerZone()
    {
        return fNumberOfCoolantPinsPerZone;   
    }
    int GetNumberOfFuelPinsPerLevel();
    int GetNumberOfGuideTubesPerLevel();
    int GetNumberOfControlRodsPerLevel();
 
 
    virtual void SetSource(
        int NPS = 5000,                 
        int ActivesCycles = 100,        
        int InactivesCycles = 100   
    ) = 0;
 
 
    string GetAssemblyName()
    {
        return fAssemblyName;   
    }
 
 
  protected:
 
    void Copy(const GenericReactorAssembly &m);
 
    virtual void CreatePlenum() = 0;
 
    virtual void CreateDuct() = 0;
 
    void Init();
 
    int FindNumInArray(int num, vector < int > Array);
 
    void FillRadialZone2MeshFromRadius();
 
    void ApplyRadialZone2Mesh();
 
    void SetGasSpaceData(double GasThickness, double GasPressure, double HeFraMol, double XeFraMol, int Zone);
 
    void AddPin(PinCell *pin, int Ix, int Iy);
 
    void ReplaceBorderPins();
 
    void CheckZoning();
 
    void PrintData();
 
    void Closing();
 
    void CountPinsPerTypePerRadialZone();
 
    void CountUniversePerRadialZone(int Rzone, vector < int > Universe, vector < int > &Nb_Of_Count);
 
    vector < int > FindUniversesInRadialZones();
 
    void FillAssemblyMesh();
 
    void SetSpatialVariable();
 
    void SetSpatialVariable(PinCell *pin, int RadialZoneNum, string RadialZoneName, double RadialZoneValue, string ZLevelName, double ZLevelValue);
 
 
 
    Shape_ptr fSAssemblyZone;   
    Shape_ptr fSOuterShape;     
    Shape_ptr fSInnerShape;     
 
    double fPitch;          
    double fAssemblyWidth;  
    double fAssemblySide;   
    double fAssemblyHeight; 
    double fAxialLevelHeight;   
    string fAssemblyName;   
    bool fIsHexagon;        
 
    vector < double > fHexaXplaneNormalVector;
 
    int fUniverse;  
 
    double fDxAssemblyTrans; 
    double fDyAssemblyTrans; 
    double fDzAssemblyTrans; 
    bool   fIsTranslated;    
 
    bool fIsAssemblyShapeDefined; 
    bool fIsAssemblyGeometryBuilt; 
 
    Shape_ptr fSPlenumUp;       
    Shape_ptr fSPlenumDown;     
    Shape_ptr fBetweenPlenums;  
 
    Material *fLowerPlenumMaterial;
    Material *fUpperPlenumMaterial;
    Cell *fCPlenumUp;           
    Cell *fCPlenumDown;         
    double fPlenumThickness;    
    bool fCanDefinePlenum;      
    bool fIsPlenum;             
 
    double fDuctThickness;  
    Material *fDuctMaterial;
    Cell *fCellDuct;        
    Shape_ptr fSAssemblyDuct; 
    bool fIsDuct;          
 
    int fAxialLevels;   
    int fRadialZones;   
    vector < vector < int > > fRadialMeshZone;
    vector < double > fVirtualRadiusCircle; 
    vector < int > fVirtualRadiusZone;       
 
 
    int fNx;            
    int fNy;            
    int fIXmin, fIXmax;  
    int fIYmin, fIYmax;  
    int fIZmin, fIZmax;  
    double fPrimitiveCellXCenter; 
    double fPrimitiveCellYCenter; 
 
    double fXMeshCenter;
    double fYMeshCenter;
    double fZMeshCenter;
 
    vector < vector < int > > fRadialMeshLattice; 
    vector < vector < vector < int > > >    fMeshLattice; 
 
    vector < PinCell *>  fRadialPinCell;  
 
    vector < vector < vector < PinCell *> > > fPinCellVector;  
 
    PinCell *fBorderPin; 
    bool fIsGuideTubes;  
    bool fIsControlRods; 
 
    vector < int > fNumberOfFuelPinsPerZone;     
    vector < int > fNumberOfGuideTubesPerZone;  
    vector < int > fNumberOfControlRodsPerZone; 
    vector < int > fNumberOfCoolantPinsPerZone; 
 
    vector < ofstream *> fFiles;        
 
    bool fIsGasSpace;               
    vector < double > fGasThickness;    
    double fGasPressure;            
    double fHeFraMol;               
    double fXeFraMol;               
 
 
};
 
#endif