EWrapper.hxx

Go to the documentation of this file.

#include <fstream>
#include <cmath>
#include <sstream>
#include <libmctal/TMTally.hxx>
#include <libmctal/TMComment.hxx>
#include <libmctal/TMctal.hxx>
#include "MureHeaders.hxx" 

using namespace std;

class MatX
{
  public:
  MatX(){M=NULL;} 
  MatX(const MatX &mx); 
  ~MatX(){} 

  Material* M; 
  double X; 
};

typedef vector<MatX> MatXX;


class CellOccupy
 {
  public:
  CellOccupy(){C=NULL;} 
  CellOccupy(const CellOccupy &co); 
  ~CellOccupy(){} 

  Cell *C; 
  vector<int> X; 
  vector<int> Y; 
  vector<int> Z; 
  int Universe; 
 };

class ReshufflingScheme 
 {
  public:
  ReshufflingScheme(){fLattice=NULL;}
  ReshufflingScheme(const ReshufflingScheme &rs);
  ~ReshufflingScheme(){}
  void AddChain(
                vector<Cell*> Chain 
                );
  void StartChain();
  void AddToChain(Cell* C);
  void SetLatticeCell(
                      Cell* Lat 
                      ){fLattice=Lat;}
  void Proceed(); 

  private:
  Cell* fLattice;
  vector< vector<CellOccupy> > fChains;
 };

class EvolutionWrapper : public EvolutionControl
{
 public:

  EvolutionWrapper();                                           
  EvolutionWrapper(const EvolutionWrapper &ev);                   
  EvolutionControl* Clone(){return new EvolutionWrapper(*this);}
  ~EvolutionWrapper(){}                         

  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) {FCMats.push_back(M);FCTitles.push_back(Title);}
  void PrintFinalCompositionNuclide(int Z, int A);
  void SetOutFile(string fn){fOutFilename=fn;} 

  
  void ControlAtEachMCNPStep(); 
  void ControlAtEachRKStep(); 
  void ControlAfterEndOfRKIntegration(); 

  

  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 AddTally(Tally* t,int* index);

  void Reshuffle(Cell* 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:
  
  double* fSumTallyEnergies;
  int fSumTallyEnergiesN;
  vector<Reaction*> fSumTallyReactions;
  vector<Cell*> fSumTallyCells; 
  vector<int*> fSumTallyIndices;
  vector<vector<ValErr_t> > fSumTallyValues;

  vector<ReshufflingScheme*> fRS; 
  vector<int> fPhaseStep; 
  vector<int> fPhaseCum; 
  vector<double> fTime; 
  vector<bool> fCool; 
  vector<MatXX> MatTTs; 
  vector<MatXX> MatBBs; 
  vector<MatXX> MatDDs; 
  vector<string> FCTitles; 
  vector<Material*> FCMats; 
  vector<int> FCZ, 
              FCA; 
  vector<int*> fTallies;
  vector<vector<ValErr_t> > fTallyValues;
  vector<double> fBurnup;
  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();
};