InLineReprocessing.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 _INLINEREPROCESSING_HXX_
#define _INLINEREPROCESSING_HXX_
 
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
 
#include "Cell.hxx"
#include "Material.hxx"
#include "EvolutionControl.hxx"
 
class Cell;
class Material;
 
 
using namespace std;
 
 
class StoredXSforZAI
{
  public:
    StoredXSforZAI(int aZ, int aA, int aI, double aXSfission = 0, double aXSng = 0, double aXSn2n = 0, double aXSn3n = 0);
    StoredXSforZAI(); 
    StoredXSforZAI(const StoredXSforZAI &storedxsforzai);
    ~StoredXSforZAI(); 
 
    int  Z()
    {
        return fZ;   
    }
    int  A()
    {
        return fA;   
    }
    int  I()
    {
        return fI;   
    }
    int  N()
    {
        return fA - fZ;   
    }
    double XSfission()
    {
        return fXSfission;
    }
    double XSng()
    {
        return fXSng;
    }
    double XSn2n()
    {
        return fXSn2n;
    }
    double XSn3n()
    {
        return fXSn3n;
    }
 
 
  private:
    int fZ;     
    int fA;     
    int fI;     
    double fXSfission;
    double fXSng;
    double fXSn2n;
    double fXSn3n;
 
};
 
 
class InLineReprocessing : public EvolutionControl
{
  public:
    InLineReprocessing();
    InLineReprocessing(const InLineReprocessing &ev);
    InLineReprocessing *Clone() override
    {
        return new InLineReprocessing(*this);   
    }
    ~InLineReprocessing() override; //<! Desctructor
 
    //Standard function for evolution controls
    void ControlAfterEachMCRun() override;  
    void ControlBeforeEachSubStep() override;   
    void ControlAfterEachEvolutionStep() override;  
    //Initialisation of time parameters
 
    void AddInLineReprocessingTimeSchema(double BurnUp, double CoolingTime, double FabricationTime, double InitialHNMass);
 
    void AddInLineReprocessingTimeSchema(double IrradiationTime, double CoolingTime, double FabricationTime);
 
 
 
 
    // Affect value to the parameters
    void SetReprocessingIrradiationTime(double Time)
    {
        fIrradiationTime = Time;   
    }
    void SetReprocessingCoolingTime(double Time)
    {
        fCoolingTime = Time;   
    }
    void SetReprocessingFabricationTime(double Time)
    {
        fFabricationTime = Time;   
    }
    void SetReprocessingKeptZ(vector < int > KeptZ)
    {
        fKept_Z = KeptZ;   
    }
    void SetReprocessingEfficience(vector < double > Efficience)
    {
        fEfficience = Efficience;   
    }
    void SetReprocessingFreshFissiles(vector < Material *> FreshFissiles)
    {
        fFreshFissiles = FreshFissiles;   
    }
    void SetReprocessingFreshFertiles(vector < Material *> FreshFertiles)
    {
        fFreshFertiles = FreshFertiles;   
    }
    void SetReprocessedCells(vector < Cell *> ReprocessedCells);
    void SetReprocessingFissilFertilProportion(vector < double > FissileFertileProportion)
    {
        fFissileFertileProportion = FissileFertileProportion;   
    }
    void SetReprocessingWantedBU(double WantedBU)
    {
        fwantedBU = WantedBU;   
    }
    void SetOxQuantity(double aOxQuantity)
    {
        fOxQuantity = aOxQuantity;   
    }
    void SetFissileFertileProportionfromsigma()
    {
        fIsFissileFertileProportionfromsigma = true;   
    }
    void UnsetFissileFertileProportionfromsigma()
    {
        fIsFissileFertileProportionfromsigma = false;   
    }
    void SetFissileFertileProportionExtrapolated()
    {
        fIsFissileFertileProportionExtrapolated = true;   
    }
    void UnsetFissileFertileProportionExtrapolated()
    {
        fIsFissileFertileProportionExtrapolated = false;   
    }
 
    //acces to the value of the parameters
    double ReprocessingIrradiationTime()
    {
        return fIrradiationTime;   
    }
    double ReprocessingCoolingTime()
    {
        return fCoolingTime;   
    }
    double ReprocessingFabricationTime()
    {
        return fFabricationTime;   
    }
    vector < Material *> ReprocessingFreshFissiles()
    {
        return fFreshFissiles;   
    }
    vector < Material *> ReprocessingFreshFertiles()
    {
        return fFreshFertiles;   
    }
    vector < double > ReprocessingFissileFertileProportion()
    {
        return fFissileFertileProportion;   
    }
    vector < Cell *> ReprocessingReprocessedCells()
    {
        return fReprocessedCells;   
    }
    vector < int > ReprocessingKeptZ()
    {
        return fKept_Z;   
    }
    vector < double > ReprocessingEfficience()
    {
        return fEfficience;   
    }
    double OxQuantity()
    {
        return fOxQuantity;   
    }
 
 
  private:
    void StoreBOC_XS(int CellNumber);
    void Reprocess(int CellNumber); 
    double CalculKHIfromSigma(int CellNumber, double AtomsKept, double AtomsToAdd);
    double ExtrapolateKHI(int CellNumber);
 
    //void BuildStorage();//!< For future developpement, tu facilitate acces to the wastes produced in a cycle
 
 
    double fIrradiationTime;
    double fIrradiationPower;
    double fCoolingTime; 
    double fFabricationTime;
 
    double fkBOC;
    double fOxQuantity;
    vector < double > fkVector; 
    vector < double > ftVector;
    double fBeginningTimeOfLastPhase;
    int fPositionInCycle;
    vector < StoredXSforZAI *> fBOC_XS;
    vector < Material *> fFreshFissiles;
    vector < Material *> fFreshFertiles;
    vector < double > fFissileFertileProportion; 
    double fwantedBU;
    double fdoneBU;
    // if the proportion btw fissil and fertil isn't defined, it's calculated at each reprocessing step
    vector < Cell *> fReprocessedCells;
    vector < int > fKept_Z; 
    vector < double > fEfficience; 
    bool fIsFissileFertileProportionfromsigma;
    bool fIsFissileFertileProportionExtrapolated;
 
    double CalculateActualTimeLimit(vector < double > kVector, vector < double > tVector, int N_rechargement, double k_threshold);
};
 
 
#endif