EWrapper.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 _EWrapper_
#define _EWrapper_
 
#include <libValErr/ValErr.hxx>
#include <fstream>
#include <cmath>
#include <sstream>
#include <vector>
#include <algorithm>
#include <string>
 
#include "Material.hxx"
#include "LatticeCell.hxx"
#include "MureTally.hxx"
#include "EvolutionControl.hxx"
 
class Cell;
class LatticeCell;
class Material;
class MureTally;
class Reaction;
 
using namespace std;
 
class MatX
{
  public:
    MatX()
    {
        fMaterial = nullptr;   
    }
    MatX(const MatX &mx); 
    ~MatX() = default; 
 
    Material *fMaterial; 
    double fValue; 
};
class MatY
{
  public:
    MatY()
    {
        fMaterial = nullptr;   
    }
    MatY(const MatY &my); 
    ~MatY() = default; 
 
    Material *fMaterial; 
    int fValue; 
};
 
typedef vector<MatX> MatXX;
typedef vector<MatY> MatYY;
 
class CellOccupy
{
  public:
    CellOccupy()
    {
        fCell = nullptr;   
    }
    CellOccupy(const CellOccupy &co); 
    ~CellOccupy() = default; 
 
    Cell *fCell; 
    vector < int > fX; 
    vector < int > fY; 
    vector < int > fZ; 
    int fUniverse; 
};
 
class ReshufflingScheme
{
  public:
    ReshufflingScheme()
    {
        fLattice = nullptr;
    }
    ReshufflingScheme(const ReshufflingScheme &rs);
    ~ReshufflingScheme() = default;
    void AddChain(
        vector < Cell *> Chain 
    );
    void StartChain();
    void AddToChain(Cell *C);
    void SetLatticeCell(
        LatticeCell *Lat 
    )
    {
        fLattice = Lat;
    }
    void Proceed();
 
  private:
    LatticeCell *fLattice;
    vector < vector < CellOccupy > > fChains;
};
 
class EvolutionWrapper : public EvolutionControl
{
  public:
 
    EvolutionWrapper();
    EvolutionWrapper(const EvolutionWrapper &ev);
    EvolutionControl *Clone() override
    {
        return new EvolutionWrapper(*this);
    }
    ~EvolutionWrapper() override;
 
    void PrintMaterialDensity(Material *M)
    {
        outDens.push_back(M);   
    }
    void PrintMaterialTemperature(Material *M)
    {
        outTemp.push_back(M);   
    }
    void PrintMaterialBoron(Material *M)
    {
        outBoron.push_back(M);   
    }
    void PrintFinalComposition(Material *M, string Title)
    {
        fFinalCompositionMaterial.push_back(M);
        fFinalCompositionTitles.push_back(Title);
    }
    void PrintFinalCompositionNuclide(int Z, int A);
    void SetOutFile(string fn)
    {
        fOutFilename = fn;   
    }
 
    void ControlAfterEachMCRun() override; 
    void ControlBeforeEachSubStep() override; 
    void ControlAfterEachEvolutionStep() override; 
 
 
    void Evolve(
        int start = 0, 
        string startd = "" 
    );
 
 
    void AddPhase(
        float T, 
        int steps, 
        int dlog = 0, 
        float bas = 2 
    );
    void SetPowerConstant(
        float P 
    );
 
    void SetPowerLinear(
        float P1, 
        float P2 
    );
    void SetPowerCooling();
    void SetMaterialTemperature(
        Material *M, 
        float X 
    );
    void SetMaterialBoron(
        Material *M, 
        float X 
    );
    void SetMaterialBoronLinear(
        Material *M, 
        float Content1, 
        float Content2 
    );
    void SetMaterialDensity(Material *M, float X);
    void SetMaterialNumberDensity(Material *M, int X);
 
 
    void AddTally(MureTally *t, int *index);
 
    void Reshuffle(LatticeCell *CLatGen); 
    void ReshuffleAddChain(vector < Cell *> Chain); 
    void ReshuffleStartChain(); 
    void ReshuffleAddToChain(Cell *C); 
    vector < vector < ValErr_t > > &GetTallyValues()
    {
        return fTallyValues;
    }
    vector < double > &GetBurnup()
    {
        return fBurnup;
    }
 
    void AddSumTally(Cell *c, Reaction *r, int *index);
 
    vector < ValErr_t > &GetSumTallyValues(int SumTally)
    {
        return fSumTallyValues[SumTally];
    }
    void SetSumTallyEnergies(int nE, double *E);
 
  protected:
 
    vector < double > fPower; 
 
  private:
 
    vector<double> fSumTallyEnergies;
    int fSumTallyEnergiesN;
    vector < Reaction *> fSumTallyReactions;
    vector < Cell *> fSumTallyCells;
    vector < int *> fSumTallyIndices;
    vector < vector < ValErr_t > > fSumTallyValues;
    vector < int *> fTallies;
    vector < vector < ValErr_t > > fTallyValues;
    vector < double > fBurnup;
 
    vector < ReshufflingScheme *> fReshufflingScheme; 
    vector < int > fPhaseStep;  
    vector < int > fPhaseCum;   
    vector < double > fTime;    
    double fPhaseEndTime;       
    vector < bool > fCool;      
 
    vector < MatXX > MatTTs; 
    vector < MatXX > MatBBs; 
    vector < MatXX > MatDDs; 
    vector < MatYY > MatMMs; 
 
    vector < string > fFinalCompositionTitles; 
    vector < Material *> fFinalCompositionMaterial; 
    vector < int > fFinalCompositionZ; 
    vector < int > fFinalCompositionA; 
 
    ofstream fOutFile; 
    string fOutFilename; 
 
    vector < Material *> outTemp; 
    vector < Material *> outDens; 
    vector < Material *> outBoron; 
 
    void BuildSumTallies();
    void EvaluateSumTallies();
 
    void outT(int start = 0); 
    void outD(int start = 0); 
    void outB(int start = 0); 
    void outH(int start = 0); 
    void PrepareTemperatureEvolution(); 
 
    void UpdatePower(int step); 
    void UpdateTempBoronDens(int step); 
    void UpdateTallies();
    void UpdateMaterialComposition(int step); 
};
 
#endif