Cell.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 _CELL_HXX_
#define _CELL_HXX_
 
#include <libValErr/ValErr.hxx>
#include <algorithm>
#include <map>
#include <string>
#include <vector>
 
#include "Reaction.hxx"
#include "Material.hxx"
#include "Shape.hxx"
#include "Transformation.hxx"
#include "BetaCollector.hxx"
#include "MCSource.hxx"
#include "TReference.hxx"
 
class EvolutiveSystem;
class BetaCollector;
class Material;
class Transformation;
//________________________________________________________________________
//
//        Cell
//________________________________________________________________________
 
struct EqualReaction
{
 
    bool operator()( Reaction r1,  Reaction r2 ) const
    {
        if(r1.GetCode()[0] < r2.GetCode()[0]) return true ;
        return false;
    }
};
 
 
class Cell
{
  public :
 
    Cell(Shape_ptr theShape, Material *theMaterial = nullptr, int theImportance = 1, double theTemperature = - 10);
 
    Cell(int theNumber, Material *theMaterial, double theVolume, int theImportance = 1, double theTemperature = - 10);
    Cell( Material *theMaterial, int theNumber, double theVolume, double theTemperature);
    Cell(const Cell &c);
    virtual Cell *Clone()
    {
        return new Cell(*this);
    }
    virtual ~Cell();    
 
    void    SetShape(Shape_ptr theShape)
    {
        fShape = theShape;   
    }
    Shape_ptr GetShape()
    {
        return fShape;   
    }
    void    SetMaterial(Material *theMaterial);             
    Material *GetMaterial()
    {
        return fMaterial;   
    }
    void    SetTemperature(double T);                       
    double  GetTemperature()
    {
        return fTemperature;   
    }
    void    SetImportance(int imp);                         
    void    SetImportance(int part, int imp)
    {
        fImportance[part] = imp;   
    }
    vector  < int > &GetImportance()
    {
        return fImportance;   
    }
    vector  < string > &GetParticle()
    {
        return fParticle;   
    }
    void    AddParticle(string Part, int Imp);              
    int     GetNumber()
    {
        return fNumber;   
    }
    void    SetNumber(int Number)
    {
        fNumber = Number;   
    }
    void    SetGlobalImportance(int imp)
    {
        fGlobalImportance = imp;   
    }
    int     GetGlobalImportance()
    {
        return fGlobalImportance;   
    }
 
    double  GetVolume()
    {
        return fVolume;
    }
    void    SetVolume(double V);
    double  GetMass();          
 
    void    SetComment(string Comment = "")
    {
        fComment = Comment;   
    }
    string  GetComment()
    {
        return fComment;   
    }
 
 
    void    AddSpatialVariable(string name, double value);
    vector  < string > &GetSpatialVariableNames()
    {
        return fSpatialVariableNames;   
    }
    vector  < double > &GetSpatialVariables()
    {
        return fSpatialVariables;   
    }
    bool    IsSpatialVariable(string name); 
    double  GetSpatialVariable(string name);
 
 
 
 
 
    // Like But methods start here
    Cell    *LikeBut(Cell *InsertionCell, Transformation *Transfo);    
    void    SetLikeNumber(int Number)
    {
        fLikeNumber = Number;    
        fIsLikeBut = true;
    }
    int     GetLikeNumber()
    {
        return fLikeNumber;   
    }
    void    SetTransformation(Transformation *TR)
    {
        fTransformation = TR;   
    }
    Transformation *GetTransformation()
    {
        return fTransformation;   
    }
    void    ExcludeCell(Cell *ACell)
    {
        fExcludedCells.push_back(ACell);   
    }
    bool    IsLikeBut()
    {
        return fIsLikeBut;
    }
    vector  < Cell *> &GetExcludedCellVector()
    {
        return fExcludedCells;
    }
 
 
    bool IsEvolving()
    {
        return fEvolving;   
    }
 
    void SetEvolutiveSystem(EvolutiveSystem *es)
    {
        fEvolutiveSystem = es;   
    }
    EvolutiveSystem *GetEvolutiveSystem()
    {
        return fEvolutiveSystem;   
    }
 
    void SetTallyNumber(int num)
    {
        fTallyNum = num;   
    }
    int  GetTallyNumber()
    {
        return fTallyNum;   
    }
    void SetTallyBinNumber(int num)
    {
        fTallyBinNum = num;   
    }
    int  GetTallyBinNumber()
    {
        return fTallyBinNum;   
    }
    void SetMultiplicatorTallyNumber(int num)
    {
        fMultiplicatorTallyNum = num;   
    }
    int  GetMultiplicatorTallyNumber()
    {
        return fMultiplicatorTallyNum;   
    }
    void SetMultiplicatorTallyBinNumber(int num)
    {
        fMultiplicatorTallyBinNum = num;   
    }
    int  GetMultiplicatorTallyBinNumber()
    {
        return fMultiplicatorTallyBinNum;   
    }
    void SetMultiplicatorTallyU8Number(int num)
    {
        fMultiplicatorTallyU8Num = num;   
    }
    int  GetMultiplicatorTallyU8Number()
    {
        return fMultiplicatorTallyU8Num;   
    }
    void SetMultiplicatorTallyU8BinNumber(int num)
    {
        fMultiplicatorTallyU8BinNum = num;   
    }
    int  GetMultiplicatorTallyU8BinNumber()
    {
        return fMultiplicatorTallyU8BinNum;   
    }
    void SetFlux(double phi)
    {
        fFlux = phi;   
    }
    void SetMCFlux(ValErr_t phi)
    {
        fMCFlux = phi;   
    }
    double GetFlux()
    {
        return fFlux;   
    }
    ValErr_t GetMCFlux()
    {
        return fMCFlux;   
    }
 
    void BuildMultiGroupFlux();                            
    void SetMultiGroupFlux(int i, ValErr_t Flux)
    {
        fPhiE[i] = Flux;   
    }
    ValErr_t GetMultiGroupFlux(int i)
    {
        return fPhiE[i];   
    }
    vector < ValErr_t > &GetMultiGroupFlux()
    {
        return fPhiE;   
    }
    int GetNEnergyGroup()
    {
        return fNEnergyGroup;   
    }
    void SetEnergyGroup(vector<float> &nrj)
    {
        fEnergyGroups = nrj;    
        fNEnergyGroup = nrj.size();
    }
    vector<float> &GetEnergyGroups()
    {
        return fEnergyGroups;   
    }
 
 
    void SetTrueCell()
    {
        fIsTrueCell = true;   
    }
    bool GetTrueCell()
    {
        return fIsTrueCell;   
    }
    void SetGlobalTallyNumber(int num)
    {
        fGlobalTallyNum = num;   
    }
    int  GetGlobalTallyNumber()
    {
        return fGlobalTallyNum;   
    }
 
    void SetCellAbsorptions(ValErr_t rate)
    {
        fCellAbsorptions = rate;   
    }
    void SetCellN2N(ValErr_t rate)
    {
        fCellN2N = rate;   
    }
    void SetCellN3N(ValErr_t rate)
    {
        fCellN3N = rate;   
    }
    void SetCellFissions(ValErr_t  rate)
    {
        fCellFissions = rate;   
    }
    void SetCellNuFissions(ValErr_t rate)
    {
        fCellNuFissions = rate;   
    }
    void SetCellNu(ValErr_t rate)
    {
        fCellNu = rate;   
    }
    void SetControlRate(Reaction r, ValErr_t rate)
    {
        fControlRate[r] = rate;
    }
    void SetControlRate(int ReactionCode, ValErr_t rate)
    {
        fControlRate[Reaction(ReactionCode)] = rate;
    }
 
    ValErr_t GetCellAbsorptions()
    {
        return fCellAbsorptions;   
    }
    ValErr_t GetCellN2N()
    {
        return fCellN2N ;   
    }
    ValErr_t GetCellN3N()
    {
        return fCellN3N ;   
    }
    ValErr_t GetCellFissions()
    {
        return fCellFissions;   
    }
    ValErr_t GetCellNuFissions()
    {
        return fCellNuFissions;   
    }
    ValErr_t GetCellNu()
    {
        return fCellNu;   
    }
    ValErr_t GetControlRate(Reaction r)
    {
        return fControlRate[r];   
    }
    ValErr_t GetControlRate(int ReactionCode)
    {
        return fControlRate[Reaction(ReactionCode)];   
    }
 
    bool IsFissile();    
    bool IsControlRod()
    {
        return fControlRod;   
    }
    void SetControlRod(double InitialLength, bool flag = true); 
    void SetControlRodLength(double l)
    {
        fControlRodLength = l;   
    }
    double GetControlRodLength()
    {
        return fControlRodLength;   
    }
 
 
    bool IsFuel()
    {
        return fFuel;   
    }
    bool IsModerator()
    {
        return fModerator;   
    }
    void SetFuel(bool flag = true)
    {
        fFuel = flag;   
    }
    void SetModerator(bool flag = true)
    {
        fModerator = flag;   
    }
 
    void SetZone(int z)
    {
        fZone = z;   
    }
    int  GetZone()
    {
        return fZone;   
    }
    void SetZlevel(int z)
    {
        fZlevel = z;   
    }
    int  GetZlevel()
    {
        return fZlevel;   
    }
 
    void SetGuideTubeCoolant()
    {
        fGuideTubeCoolant = true;   
    }
    bool IsGuideTubeCoolant()
    {
        return fGuideTubeCoolant;   
    }
    double GetLocalKeff();  
 
    void AddBetaCollector(BetaCollector *BC)
    {
        fCellBetaCollectors.push_back(BC);   
    }
 
    bool IsVirtual()
    {
        return fVirtual;   
    }
    bool IsFromPinCell()
    {
        return fIsFromPinCell;   
    }
    void SetFromPinCell(bool flag)
    {
        fIsFromPinCell = flag;   
    }
    bool IsAPinCell()
    {
        return fIsAPinCell;   
    }
    bool IsPrintable()
    {
        return fIsPrintable;   
    }
    void SetPrintable(bool flag)
    {
        fIsPrintable = flag;   
    }
 
    void SetTHLevelPosition(int level)
    {
        fTHLevelPosition = level;   
    }
    int  GetTHLevelPosition()
    {
        return fTHLevelPosition;   
    }
    void SetTHZonePosition(int zone)
    {
        fTHZonePosition = zone;   
    }
    int  GetTHZonePosition()
    {
        return fTHZonePosition;   
    }
 
    void AddToNuNSigmaFisPhi(double Value)
    {
        fNuNSigmaFisPhiTotalOfCell += Value;   
    }
    void SetNuNSigmaFisPhi(double Value)
    {
        fNuNSigmaFisPhiTotalOfCell = Value;   
    }
    double GetNuNSigmaFisPhi()
    {
        return fNuNSigmaFisPhiTotalOfCell;   
    }
    void SetNSigmaFisPhiOfNucleus(int i, double Value)
    {
        fNSigmaFisPhiOfNucleus[i] = Value;   
    }
    double GetNSigmaFisPhiOfNucleus(int i)
    {
        return fNSigmaFisPhiOfNucleus[i];   
    }
    vector < double > GetNSigmaFisPhiOfAllNucleus()
    {
        return fNSigmaFisPhiOfNucleus;   
    }
 
    virtual int GetUniverse()
    {
        return fShape -> GetUniverse();   
    }
 
  protected:
    Cell(); //default protected constructor
 
    int     fNumber;        
    Shape_ptr fShape;       
    Material *fMaterial;    
    double  fTemperature;   
    double  fFlux;          
    ValErr_t fMCFlux;       
    int     fGlobalImportance; 
    vector  < int > fImportance;    
    vector  < string > fParticle;   
    string  fComment;       
    double  fVolume;        
 
    bool    fEvolving;  
    double  fMass;      
    double  fNatoms;    
    EvolutiveSystem *fEvolutiveSystem;  
 
    int     fTallyNum;  
    int     fTallyBinNum;   
    int     fGlobalTallyNum;            
    int     fMultiplicatorTallyNum;     
    int     fMultiplicatorTallyBinNum;  
    int     fMultiplicatorTallyU8Num;   
    int     fMultiplicatorTallyU8BinNum;
 
    vector  < double > fSpatialVariables;        
    vector  < string > fSpatialVariableNames;    
 
    bool    fIsTrueCell;            
 
    vector  < BetaCollector *> fCellBetaCollectors; 
 
    ValErr_t    fCellAbsorptions;   
    ValErr_t    fCellN2N;           
    ValErr_t    fCellN3N;           
    ValErr_t    fCellNuFissions;    
    ValErr_t    fCellFissions;      
    ValErr_t    fCellNu;            
    map     < Reaction, ValErr_t, EqualReaction > fControlRate;    
    bool    fCellCanFission;        
    vector  < double > fCellGlobalRatesVector;
 
    int     ***fTransLattice;   
 
    bool    fControlRod;        
    double  fControlRodLength;  
 
    // All the variables needed to define cells as Like But
    bool    fIsLikeBut;             
    int     fLikeNumber;            
    Transformation *fTransformation;
    vector < Cell *> fExcludedCells;
 
    bool    fFuel;      
    bool    fModerator; 
    bool    fGuideTubeCoolant;  
 
    bool    fVirtual;   
 
    int     fZlevel;    
    int     fZone;      
    int     fTHLevelPosition;   
    int     fTHZonePosition;    
 
    double  fLocalKeff; 
    vector  < ValErr_t > fPhiE; 
    vector  <float> fEnergyGroups;     
    int     fNEnergyGroup;      
    double  fNuNSigmaFisPhiTotalOfCell;     
    vector  < double > fNSigmaFisPhiOfNucleus; 
    bool    fIsPrintable;  
    bool    fIsFromPinCell;
    bool    fIsAPinCell;   
};
 
#endif