InLineReprocessingEvolutionControl.hxx

Go to the documentation of this file.

#ifndef _INLINEREPROCESSINGEVOLUTIONCONTROL_HXX_
#define _INLINEREPROCESSINGEVOLUTIONCONTROL_HXX_

#include <iostream>
#include <vector>
#include <string>

#include "MureHeaders.hxx"


using namespace std;


class StoredXSforZAI
{
 public:
    StoredXSforZAI(int Z, int A, int I,double XSfission=0,double XSng=0,double XSn2n=0,double XSn3n=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(){return new InLineReprocessing(*this);} //@- Correct way to copy a InLineReprocessing in case of derivation
    ~InLineReprocessing(){}// Desctructor
    
    //Standard function for evolution controls
    void ControlAtEachMCNPStep();           //@- control at each MCNP step (just after a MCNP run)
    void ControlAtEachRKStep();             //@- control at each RK step (just before a RK step)
    void ControlAfterEndOfRKIntegration();  //@- control at the end of the RK integration, just before an other MCNP run.

    //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){WantedBU=fwantedBU;}
    void SetOxQuantity(double OxQuantity){fOxQuantity=OxQuantity;}
    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