EvolutiveSystem.hxx

Go to the documentation of this file.

#ifndef _EvolutiveSystem_
#define _EvolutiveSystem_ 

#include <math.h>
#include <vector>
#include "MureHeaders.hxx" 


using namespace std; 

//-----------------------------------------------------------------------------//


      

//________________________________________________________________________

class EvolutiveSystem : public DynamicalSystem
{
 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 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;}  
    bool IsEvolving(){return fEvolve;}              
    void SetEvolve(bool flag=true){fEvolve=flag;}   
    string PrintEvolvingAtoms();    
    void CalculateNuSigmaFisPhis(); 
    void FindIndexMass135();    

    void FindXe135Equilibrium();
    
 protected :
    void CalculatePower(); 

    Material*   fEvolvingMaterial;  
    Cell*       fEvolvingCell;      
    double      *fEvolvingAtoms;    
    double      *fPCEvolvingAtoms;  
    double      fTmin;              
    double      **fTheMatrix;       
    double      fPower;             
    double      fPowerErr;          
    double      fPowerDensity;      
    bool        fAlreadyTransmodrified; 
    bool        fEvolve;
    
    int         fIdxTe135;  
    int         fIdxI135;   
    int         fIdxXe135;  
    double     fNI135;      
    double     fNXe135;     
    double     fOldFlux;    
    double     fMeanFlux;   
    double     fFirstTNF;   
    
}; 

#endif