EvolutiveSystem.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 _EvolutiveSystem_
#define _EvolutiveSystem_
#include <vector>
#include <iosfwd>
#include <string>
 
// #include "DynamicalSystem.hxx"
//#include "Cell.hxx"
#include "Material.hxx"
#include "CRAMSolver.hxx"
#include "RKSolver.hxx"
 
class Cell;
class BatemanSolver;
class Material;
 
using namespace std;
 
//-----------------------------------------------------------------------------//
 
 
 
 
//________________________________________________________________________
 
class EvolutiveSystem
{
  public :
 
    EvolutiveSystem(Cell *cell);        
    EvolutiveSystem(Material *mat);     
    EvolutiveSystem(const EvolutiveSystem  &ES);
    ~EvolutiveSystem();                 
 
 
    void TransmogrifyMaterial();
 
    void PredictorTransmogrifyMaterial();
 
    void CorrectorTransmogrifyMaterial();
 
    void TransmogrifyGroupCell();
 
    void PredictorTransmogrifyGroupCell();
 
    void CorrectorTransmogrifyGroupCell();
 
    void TransmogrifyEvolvingAtoms();
    int GetEvolvingCompositionSize()
    {
        return fNVar;   
    }
    void SetEvolvingCompositionSize(int n)
    {
        fNVar = n;   
    }
    void CalculateEvolvingAtoms();                                
    void SetEvolvingAtoms(int i, double proportion)
    {
        fEvolvingAtoms[i] = proportion;   
    }
    double GetEvolvingAtoms(int i)
    {
        if ( ! fEvolvingAtoms)
        {
            CalculateEvolvingAtoms();   
        }
        return fEvolvingAtoms[i];
    }
    void SetEvolvingAtoms(double *f)
    {
        fEvolvingAtoms = f;   
    }
    double *GetEvolvingAtoms()
    {
        if ( ! fEvolvingAtoms)
        {
            CalculateEvolvingAtoms();   
        }
        return fEvolvingAtoms;
    }
    bool IsTransmogrify()
    {
        return fAlreadyTransmodrified;   
    }
    void SetTransmogrify(bool flag)
    {
        fAlreadyTransmodrified = flag;   
    }
 
    Cell *GetCell()
    {
        return fEvolvingCell;   
    }
    Material *GetMaterial()
    {
        return fEvolvingMaterial;   
    }
    void SetCell(Cell *c)
    {
        fEvolvingCell = c;   
    }
    void SetMaterial(Material *m)
    {
        fEvolvingMaterial = m;   
    }
 
 
    // using DynamicalSystem::RungeKutta;
 
    // void RungeKutta(double t1, double t2);
    void Solve(double t1, double t2); // calls unified solver
 
 
    // void BuildEqns(double t, double *N, double *dNdt);
    void SetMatrixToZero();            
    void LoadTheMatrix(int index);    
    void SetTheMatrix(double * *f)
    {
        fTheMatrix = f;   
    }
    double * *GetTheMatrix()
    {
        return fTheMatrix;   
    }
 
    double GetPower()
    {
        CalculatePower();    
        return fPower;
    }
    double GetPowerErr()
    {
        return fPowerErr;   
    }
    double GetPowerDensity()
    {
        CalculatePower();    
        return fPowerDensity;
    }
    void SetPowerFrac(double powerfrac)
    {
        fPowerFrac = powerfrac;
    };
    double GetPowerFrac()
    {
        return fPowerFrac;
    };
    double GetAvgQ()
    {
        return fAvgQ;
    };
    void SetAvgQ(double AvgQ)
    {
        fAvgQ = AvgQ;
    };
 
    void Init()
    {
        CalculateInitialHNMass();
    }
    double GetBurnup()
    {
        return fBurnup;   
    }
    void UpdateBurnupHistory(double deltaT, bool cool); // external method
    bool IsEvolving()
    {
        return fEvolve;   
    }
    void SetEvolve(bool flag = true)
    {
        fEvolve = flag;   
    }
    string PrintEvolvingAtoms();    
    void CalculateNuSigmaFisPhis();    
    void FindIndexMass135();    
 
    void FindXe135Equilibrium();
 
  protected :
    void CalculatePower(); 
    void UpdateBurnupHistory(double deltaT); // Local method only
    void CalculateInitialHNMass();
    void SetSolver(); 
 
    BatemanSolver *fBatemanSolver;  // !<Bateman solver class (CRAM or RungeKutta)
 
    Material    *fEvolvingMaterial; 
    Cell        *fEvolvingCell;     
    double      *fEvolvingAtoms;    
    double      *fPCEvolvingAtoms;  
 
    int         fNVar;      
    double      **fTheMatrix;
 
    double      fPower;             
    double      fPowerErr;          
    double      fPowerDensity;        
    double      fBurnup;            
    double      fPowerFrac;         
    double      fAvgQ;              
 
    double      fInitHNMassInTon;
    bool        fNMassInTonInitialized;
    bool        fAlreadyTransmodrified; 
    bool        fEvolve;
 
    int         fIdxTe135;  
    int         fIdxI135;   
    int         fIdxXe135;  
    double      fNI135;     
    double      fNXe135;    
 
    double      fOldFlux;   
    double      fMeanFlux;  
    double      fFirstTNF;  
 
};
 
#endif