COBRA_EN.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 _COBRA_EN_HXX
#define _COBRA_EN_HXX
 
#include <vector>
#include <fstream>
#include <string>
 
#include "GenericReactorAssembly.hxx"
 
using namespace std;
 
 
 
class COBRA_EN
{
  public:
    COBRA_EN(GenericReactorAssembly *GRA);
    virtual ~COBRA_EN(); 
    COBRA_EN();  
    virtual COBRA_EN *Clone()
    {
        return new COBRA_EN(*this);   
    }
 
    void SetInletTemperature(double T)
    {
        fInletTemperature = T;   
    }
    void SetInletMassFlux(double Q)
    {
        fInletMassFlux = Q;   
    }
    void SetInletBoronConcentration(double C)
    {
        fInletBoronConcentration = C;   
    }
    void SetExitPressure(double P)
    {
        fExitPressure = P;   
    }
    void BuildCOBRAFile();      
    void SetSpacerGridsCoeff(double GridCoefficient)
    {
        fSpacerGridCoeff = GridCoefficient;   
    }
    void AddSpacerGridsPos(double Pos)
    {
        fSpacerGridPositions.push_back(Pos);   
    }
    static void ResetSigmaPhiBool()
    {
        fSigmaPhiUpdated = false;
    }
    GenericReactorAssembly *GetReactorAssembly()
    {
        return fReactorAssembly;   
    }
 
    void SetInletDensity(double D)
    {
        fInletDensity = D;
    }
    void SetUserHydraulicsModel()
    {
        fHydraulicModelIndicators = true;   
    }
 
  protected:
 
    void Card1();     
    void Card2();     
    void Card3();     
    void Card4();     
    void Card5();     
    void Card7();     
    void Card8();     
    void Card10();    
    void Card11();    
    void Card12();    
    void Card14();    
    void Card18();    
    void Card20();    
    void Card22();    
    void Card26();    
    void Card27();    
    void Card29();    
    void Card30();    
    void Card32();    
    void Card36();    
 
 
    COBRA_EN(const COBRA_EN &c);
    void Init();
    void THDataCalculations();
    void MeshGridMC();
    void CardComment(int N, string Comment);
 
    string InputCardTruncate(double Value, int CharNumber, bool MustBeADouble = false);
 
    void CalculatePowerDeposits();
    void CalculateChannelsPositions();
    vector < double > CalculateChannelConnectionAndData(int ChannelNumber);
    vector < double > IdentifyRodsToSubChannelsConnexion(int RodNumber);
    void OrganizeChannels();
    void PrintData();
    void PrintNewTHData();
    void RunCOBRA();
    void CheckRestrictions();
 
 
    void UpdateData();
    void CheckOutputFile();
    void ExtractData();
    void MCCellsDataAverages();
    void MCZonesDataAverages();
    void RebootStrapping();
 
 
 
  private:
 
    GenericReactorAssembly *fReactorAssembly;
    static bool fSigmaPhiUpdated;   
    bool fHydraulicModelIndicators; 
    string fAssemblyName;       
    int fFuelRodsNumber;        
    int fChannelsNumber;        
    int fChannelType;           
    int fNDX;                   
    double fInletTemperature;   
    double fInletDensity;       
    double fInletMassFlux;      
    double fInletBoronConcentration;    
    double fExitPressure;       
    string fDirectory;          
    ofstream *fInputFile;       
    ifstream *fOutputFile;      
    int fNumberOfSpacerGrids;           
    double fSpacerGridCoeff;            
    vector < double > fSpacerGridPositions;     
    vector < vector < double > > fPower;    
    vector < vector < double > > fPowerErr;     
    vector < vector < int > > fCOBRARodsLatticeNumbering;   
    vector < vector < int > > fCOBRAChannelsLatticeNumbering;   
    vector < vector < double > > fCOBRAChannelsRCXPos;      
    vector < vector < double > > fCOBRAChannelsRCYPos;      
    vector < vector < double > > fCOBRAChannelsCenterXPos;  
    vector < vector < double > > fCOBRAChannelsCenterYPos;  
    vector < vector < int > > fChannelTypes;                
    vector < double > fChannelFlowArea;             
    vector < double > fChannelWettedPerimeter;  
    vector < double > fChannelHeatedPerimeter;  
 
    vector < vector < double > > fMUREFuelCellsTemp;            
    vector < vector < double > > fMURECladCellsTemp;            
    vector < vector < double > > fMURECoolantCellsTemp;             
    vector < vector < double > > fCOBRACoolantChannelDensity;   
    vector < vector < double > > fMURECoolantCellsDensity;      
 
    double fOutletMeanTemperature;      
    double fOutletMeanDensity;          
 
    vector < ofstream *> fFiles;            
};
 
#endif