diff --git a/Utils/trunk/LICENSE b/Utils/trunk/LICENSE
deleted file mode 100644
index 5468e0d4246a2b12c226e409ec230a83e3839957..0000000000000000000000000000000000000000
--- a/Utils/trunk/LICENSE
+++ /dev/null
@@ -1,18 +0,0 @@
-Computer Program Services
-Restrictions on the use of programs and data
-
-Authors and their establishments must be consulted if an organisation receiving programs and data intends to use them to provide commercial service to outside users.
-
-Programs and data are provided on the understanding that the agreement of the originating establishment shall be obtained before a service is offered involving sale or use on a fee-paying basis of the program or data set. This restriction applies also to modified versions derived from program copies obtained from the in2p3 Forge.
-
-Transfer of a program or data to a user in a given establishment confers only the right to use the program within that organisation: in particular, copies of programs and data should not be distributed to persons outside their own establishment; users in other centres should contact the development team directly in order to obtain program copies.
-
-Computer programs and data are provided on the understanding that whenever the use of programs, or locally modified versions of them, results in a publication (a journal, conference proceedings, laboratory report, book etc.), the program and its author or laboratory of origin shall be acknowledged in the publication.
-
-To be more specific as to how these restrictions must be interpreted the following should be noted:
-the codes users receive from the in2p3 Forge cannot be further distributed, thereby prohibiting the sale of such material, if users modify codes, they must inform the authors. Improved versions may not be sold without users coming to an agreement with the principal authors, users are not permitted to set up the code on a shared computer which allows other users to access the code by paying a royalty for its use, however, there is no objection to expert users within a contract or project with a third party, modelling a problem, interpreting results and recovering the cost of their work and expertise by using a code received from the in2p3 Forge.
-
-DISCLAIMER
-
-Neither the author nor their establishments assumes any liabilities with respect to the use of, or for damage resulting from the use of, any information, method or process disclosed in the distributed material.
-
diff --git a/Utils/trunk/MURE2CLASS/BinaryFormat2.hxx b/Utils/trunk/MURE2CLASS/BinaryFormat2.hxx
new file mode 100644
index 0000000000000000000000000000000000000000..570a0010d01541da8e784a9c48cdd8b2bb0c2156
--- /dev/null
+++ b/Utils/trunk/MURE2CLASS/BinaryFormat2.hxx
@@ -0,0 +1,141 @@
+#ifndef _BINARYFORMAT2_
+#define _BINARYFORMAT2_
+
+#include <fstream>
+using namespace std;
+
+/*!
+ \file
+ \brief Header file for binary output files management.
+
+ This file is to be included in any units which manipulate (read/void write) MURE
+ binary output files. These structures allow easy way to handle
+ binary output of MURE evolution data (BDATA_* files).
+
+ @author JW
+ @author PTO
+ @version 1.0
+*/
+
+//! Header of MURE output binary file
+struct FileHeader
+{
+ FileHeader() {Version=1;} //!< Constructor
+ short Version; //!< Binary gile version
+ float Time; //!< Time of MCNP step at which this file is printed
+ float K; //!< keff
+ float Kerr; //!< keff error
+ int NCells; //!< Number of evolving cells
+ void write(ofstream &out); //!< Write the header into a stream
+ void read(ifstream &in); //!< Read the header from a stream
+};
+
+//! Header of an evolving cell in a binary file
+struct CellHeader
+{
+ int CellNumber; //!< MCNP number of this cell
+ float Volume; //!< Volume of the cell
+ float Flux; //!< Flux in this cell
+ float FluxErr; //!< Flux error
+ int NNucleusRecords; //!< Number of nuclei records in this cell
+ void write(ofstream &out); //!< Write the header into a stream
+ void read(ifstream &in); //!< Read the header from a stream
+};
+
+//! Record of a nucleus in a binary file
+struct NucleusRecord
+{
+ short Z; //!< Proton number of the nucleus
+ short A; //!< Nucleon number of the nucleus
+ short I; //!< Isomeric state of the nucleus
+ float Mass; //!< Atomic mass
+ float Proportion; //!< Number of this nuclei in cell
+ short NReactionRecords; //!< Number of reaction records of this nucleus
+ void write(ofstream &out); //!< Write the record into a stream
+ void read(ifstream &in); //!< Read the record from a stream
+};
+
+//! Record of a reaction in a binary file
+struct ReactionRecord
+{
+ short Code; //!< Reaction code
+ float Sigma; //!< Reaction cross-section
+ float SigmaErr; //!< Cross-section error
+ void write(ofstream &out); //!< Write the record into a stream
+ void read(ifstream &in); //!< Read the record from a stream
+};
+//--------------------------------------------------------
+// Implementation of methods
+//-------------------------------------------------------
+void FileHeader::write(ofstream &out)
+{
+ out.write((char*)&Version,sizeof(Version));
+ out.write((char*)&Time,sizeof(Time));
+ out.write((char*)&K,sizeof(K));
+ out.write((char*)&Kerr,sizeof(Kerr));
+ out.write((char*)&NCells,sizeof(NCells));
+}
+
+void FileHeader::read(ifstream &in)
+{
+ in.read((char*)&Version,sizeof(Version));
+ in.read((char*)&Time,sizeof(Time));
+ in.read((char*)&K,sizeof(K));
+ in.read((char*)&Kerr,sizeof(Kerr));
+ in.read((char*)&NCells,sizeof(NCells));
+}
+
+void CellHeader::write(ofstream &out)
+{
+ out.write((char*)&CellNumber,sizeof(CellNumber));
+ out.write((char*)&Volume,sizeof(Volume));
+ out.write((char*)&Flux,sizeof(Flux));
+ out.write((char*)&FluxErr,sizeof(FluxErr));
+ out.write((char*)&NNucleusRecords,sizeof(NNucleusRecords));
+}
+
+void CellHeader::read(ifstream &in)
+{
+ in.read((char*)&CellNumber,sizeof(CellNumber));
+ in.read((char*)&Volume,sizeof(Volume));
+ in.read((char*)&Flux,sizeof(Flux));
+ in.read((char*)&FluxErr,sizeof(FluxErr));
+ in.read((char*)&NNucleusRecords,sizeof(NNucleusRecords));
+}
+
+void NucleusRecord::write(ofstream &out)
+{
+ out.write((char*)&Z,sizeof(Z));
+ out.write((char*)&A,sizeof(A));
+ out.write((char*)&I,sizeof(I));
+ out.write((char*)&Mass,sizeof(Mass));
+ out.write((char*)&Proportion,sizeof(Proportion));
+ out.write((char*)&NReactionRecords,sizeof(NReactionRecords));
+}
+
+void NucleusRecord::read(ifstream &in)
+{
+ in.read((char*)&Z,sizeof(Z));
+ in.read((char*)&A,sizeof(A));
+ in.read((char*)&I,sizeof(I));
+ in.read((char*)&Mass,sizeof(Mass));
+ in.read((char*)&Proportion,sizeof(Proportion));
+ in.read((char*)&NReactionRecords,sizeof(NReactionRecords));
+}
+
+void ReactionRecord::write(ofstream &out)
+{
+ out.write((char*)&Code,sizeof(Code));
+ out.write((char*)&Sigma,sizeof(Sigma));
+ out.write((char*)&SigmaErr,sizeof(SigmaErr));
+}
+
+void ReactionRecord::read(ifstream &in)
+{
+ in.read((char*)&Code,sizeof(Code));
+ in.read((char*)&Sigma,sizeof(Sigma));
+ in.read((char*)&SigmaErr,sizeof(SigmaErr));
+}
+
+
+#endif
diff --git a/Utils/trunk/MURE2CLASS/MURE2CLASS.cxx b/Utils/trunk/MURE2CLASS/MURE2CLASS.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..8b4c546bf19a9c66bc84274a4920801ddec5f3b8
--- /dev/null
+++ b/Utils/trunk/MURE2CLASS/MURE2CLASS.cxx
@@ -0,0 +1,753 @@
+#include "BinaryFormat2.hxx"
+#include "StringLine.hxx"
+#include "ZAI.hxx"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <algorithm>
+
+using std::string;
+using namespace std;
+
+//----------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+//------------------------------------- METHODS ------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+
+string itoa(int num)
+{
+ ostringstream os(ostringstream::out);
+ os << "" << num;
+ return os.str();
+}
+
+int ReadCommentVersion(ifstream& in, string filename)
+{
+ if(!in.good())
+ {
+ cerr << "ERROR in MureRead:: Cannot find ASCII file " << filename << " to Read" << endl;
+ return -1;
+ }
+ //
+ //Go throught the comments at the beginning of the file and Read the version number of Data Format
+ //
+ string TheComment;
+ int MureDataVersion;
+ bool bComment=true;
+ while (bComment)
+ {
+ in>>TheComment;
+ if (TheComment=="%")
+ {
+ getline(in,TheComment); // the "in>>" command keep the cursor at the end of line
+ }
+ else if (TheComment=="V")
+ {
+ in>>MureDataVersion;
+ bComment=false;
+ }
+ else
+ {
+ cout << "No comments or format version at the beginning of data files" << endl;
+ bComment=false;
+ MureDataVersion=0;
+ }
+ }
+ return MureDataVersion;
+}
+
+//----------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+//------------------------------------- MAIN ---------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+
+int main(int argc, char** argv)
+{
+
+ // =========================================================================================
+ // VARIABLES
+ // =========================================================================================
+ string sPWD = getenv("PWD");
+
+ string s_tmp = ""; int i_tmp = 0; double tmp = 0;
+ string DataASCIIFile = "DATA_"; int NDataASCIIFile = 0;
+ string DataBinFile = "BDATA_"; int NDataBinFile = 0;
+ string DataFile = ""; int NDataFile = 0;
+ string LastDataFile = "";
+
+ string OutDataFile = "";
+ string OutDataFileInfo = "";
+ string OutLOG = "";
+
+ bool IsThereASCCIFile = false;
+ bool IsThereBinFile = false;
+
+ vector <int> vCellNumber;
+ vector <string> vCellComment;
+
+ int NumberOfCells = 1;
+
+ vector < double > vTime;
+ vector < double > vKeff;
+ vector < double > vFlux;
+ vector < vector < double > > vFlux1;
+
+ vector <ZAI > zai1;
+ vector <vector <ZAI > > zai2;
+ vector <vector <vector<ZAI > > > zai3;
+
+ vector <ZAI > zai_FS_1;
+ vector <vector <ZAI > > zai_FS_2;
+ vector <vector <vector<ZAI > > > zai_FS_3;
+
+
+ vector <ZAI > zai_SC_1;
+ vector <vector <ZAI > > zai_SC_2;
+ vector <vector <vector<ZAI > > > zai_SC_3;
+
+
+ vector <ZAI > zai_SN_1;
+ vector <vector <ZAI > > zai_SN_2;
+ vector <vector <vector<ZAI > > > zai_SN_3;
+
+
+ vector <bool > HasToBePrint;
+
+ // =========================================================================================
+ // WELCOME !
+ // =========================================================================================
+
+ // MURE output path
+ if(argc != 9)
+ {
+ cout << "Argument problem for MURE2CLASS... EXIT!" << endl;
+ cout << "Arg should be :" << endl << "\t1 Path," << endl << "\t2 OutName," << endl << "\t3 ReactorType," << endl << "\t4 FuelType," << endl;
+ cout << "\t5 Power," << endl << endl << "\t6 NormalizationFactor(Before Normalization)," << endl << "\t7 WantedCell (by default should be 0)" << endl << "\t8 Step to Skip," << endl;
+ exit(1);}
+ string DBPath = sPWD + "/" + argv[1];
+ string OutName = argv[2];
+ string ReactorType = argv[3];
+ string FuelType = argv[4];
+
+ string Power = argv[5];
+ double NormalizationFactor = atof(argv[6]);
+ int WantedCell = atoi(argv[7]);
+ int StepToSkip = atoi(argv[8]);
+ // Name of the output file
+ OutDataFile = "./" + OutName + ".dat";
+ OutDataFileInfo = "./" + OutName + ".info";
+ OutLOG = "./" + OutName + ".log";
+
+ ofstream OutputLog(OutLOG.c_str());
+
+ // Check how many DATAxxx and BDATAxxx files there are
+ string Command = "find " + DBPath + " -name \"" + DataASCIIFile + "*\" > ASCII.tmp";
+ system(Command.c_str());
+ Command = "find " + DBPath + " -name \"" + DataBinFile + "*\" > BIN.tmp";
+ system(Command.c_str());
+
+ ifstream ASCIITMP("ASCII.tmp");
+ if (ASCIITMP.is_open())
+ {
+ while (!ASCIITMP.eof())
+ {
+ getline(ASCIITMP,s_tmp);
+ i_tmp++;
+ }
+ } ASCIITMP.close(); i_tmp--; NDataASCIIFile = i_tmp;
+
+ i_tmp=0;
+ ifstream BINTMP("BIN.tmp");
+ if (BINTMP.is_open())
+ {
+ while (!BINTMP.eof())
+ {
+ getline(BINTMP,s_tmp);
+ i_tmp++;
+ }
+ } BINTMP.close(); i_tmp--; NDataBinFile = i_tmp;
+
+ // Remove temporary files...
+ Command = "\\rm -f ASCII.tmp BIN.tmp";
+ system(Command.c_str());
+
+ // Say if there is Binary or ASCII file
+ if (NDataASCIIFile>0) {IsThereASCCIFile=true; DataFile = DataASCIIFile; NDataFile = NDataASCIIFile;}
+ else if (NDataBinFile>0) {IsThereBinFile =true; DataFile = DataBinFile; NDataFile = NDataBinFile;}
+ else {cout << endl << "There is no MURE DATA file in the given path... EXIT!" << endl << endl; exit(1);}
+
+ // =========================================================================================
+ // READ (B)DATA files...
+ // =========================================================================================
+
+ OutputLog << endl;
+ OutputLog << "===================================================" << endl;
+ OutputLog << "---------------------------------------------------" << endl;
+ if (IsThereBinFile) OutputLog << endl << "Binary file detected... " << endl << endl;
+ else cout << endl << "ASCII file detected... " << endl << endl;
+ // /*sleep(1)*/;
+
+ for (int t=0; t<NDataFile; t++)
+ {
+ string SFX = "";
+ if (t<=9) SFX = "00" + itoa(t);
+ else if (t>=10 && t<=99) SFX = "0" + itoa(t);
+ else if (t>=100 && t<=999) SFX = "" + itoa(t);
+ else {cout << endl << "there is more than 1000 DATA files, not yet implemented... EXIT!" << endl << endl; exit(1);}
+ string s_File = DBPath + "/" + DataFile + SFX;
+ if (t%10==0) {string ff = DataFile + SFX; cout << "Reading file " << ff << endl; /*sleep(1)*/;}
+ LastDataFile = DataFile + SFX;
+
+ // READ BINARY FILE
+ if (IsThereBinFile)
+ {
+ ifstream in(s_File.c_str(),ios::binary);
+ if(!in.good()){cout << "Cannot find Binary file " << s_File << endl; exit(0);}
+ //
+ //Read The version number of writing Mure evolving Data Format
+ //
+ char TextV;
+ int MureDataVersion=0;
+ in.read((char*)&TextV, sizeof(char));
+
+ if(TextV=='V') in.read((char*)&MureDataVersion, sizeof(int));
+ else {in.close(); in.clear(); in.open(s_File.c_str(),ios::binary);}
+
+ string TheComment;
+
+ // Read the File Header
+ FileHeader FH;
+ FH.read(in);
+ NumberOfCells = FH.NCells;
+
+ // --------------------------- TIME ----------------------
+ vTime.push_back(FH.Time);
+ vKeff.push_back(FH.K);
+
+ CellHeader CH;
+ NucleusRecord NR;
+ bool STOP2READ=false;
+
+ for(int c=0 ; c<NumberOfCells; c++)
+ {
+ if(STOP2READ)break;
+ CH.read(in);
+ vFlux.push_back(CH.Flux);
+
+ // read the Cell Comment
+ int StringSize; in.read((char*)&StringSize, sizeof(int)); TheComment.resize(StringSize);
+ char tmp[StringSize+1]; in.read(tmp, (StringSize+1)*sizeof(char)); tmp[StringSize]='\0';
+ TheComment=tmp;
+
+ bool SkipCell=false;
+ if(CH.CellNumber<0 && TheComment!="WasteStorage") SkipCell=true;
+ if(TheComment=="WasteStorage") STOP2READ=true;
+
+ if (t==0)
+ {
+ vCellNumber.push_back(CH.CellNumber);
+ vCellComment.push_back(TheComment);
+ }
+
+ //read the spatial variables
+ int NSpatialVariables; in.read((char*)&NSpatialVariables, sizeof(int));
+
+ vector<double> SpatialVariables(NSpatialVariables);
+ vector<string> SpatialVariableNames;
+
+ for(int j=0; j<NSpatialVariables; j++) in.read((char*)&SpatialVariables[j],sizeof(double));
+
+ //read the spatial variable names
+ for(int j=0; j<NSpatialVariables; j++)
+ {
+ int StringSize; in.read((char*)&StringSize,sizeof(int));
+ s_tmp=""; s_tmp.resize(StringSize); char tmp[StringSize+1];
+ in.read(tmp, (StringSize+1)*sizeof(char)); tmp[StringSize]='\0';
+ s_tmp=tmp; SpatialVariableNames.push_back(s_tmp);
+ }
+
+ for(int i=0; i<CH.NNucleusRecords; i++)
+ {
+ // Read the Nucleus Record
+ NR.read(in);
+
+ if(!SkipCell)
+ {
+ ZAI zai(NR.Z, NR.A, NR.I, NR.Proportion);
+ zai1.push_back(zai);
+ //if (t==0 && NR.Proportion>=2e+25) cout << NR.Z << " " << NR.A << " " << NR.I << " " << NR.Proportion << endl;
+ }
+
+ ReactionRecord RR;
+ for (int k=0; k<NR.NReactionRecords; k++)
+ {
+ RR.read(in);
+ if(RR.Sigma==0.0) RR.Sigma=1e-10;
+
+ if(!SkipCell)
+ {
+ ZAI zai(NR.Z, NR.A, NR.I, RR.Sigma);
+ if (RR.Code==18) zai_FS_1.push_back(zai);
+ if (RR.Code==102) zai_SC_1.push_back(zai);
+ if (RR.Code==16) zai_SN_1.push_back(zai);
+
+ }
+
+
+
+
+
+ }
+ }
+ if(!SkipCell)
+ {
+ zai2.push_back(zai1);
+ zai1.clear();
+ zai_FS_2.push_back(zai_FS_1);
+ zai_FS_1.clear();
+ zai_SC_2.push_back(zai_SC_1);
+ zai_SC_1.clear();
+ zai_SN_2.push_back(zai_SN_1);
+ zai_SN_1.clear();
+ }
+ }
+ in.close();
+ zai3.push_back(zai2); zai2.clear();
+ zai_FS_3.push_back(zai_FS_2); zai_FS_2.clear();
+ zai_SC_3.push_back(zai_SC_2); zai_SC_2.clear();
+ zai_SN_3.push_back(zai_SN_2); zai_SN_2.clear();
+
+ vFlux1.push_back(vFlux); vFlux.clear();
+
+ }
+ // READ ASCII FILE
+ else if (IsThereASCCIFile)
+ {
+ ifstream in(s_File.c_str());
+ int TranspCode=1;
+ if(!in.good()) {if(!in.good()){OutputLog << "Cannot find ASCII file " << s_File << endl; exit(0);}}
+ //
+ //Read The version number of writing Mure evolving Data Format
+ //
+ int MureDataVersion=ReadCommentVersion(in, s_File);
+ if(MureDataVersion==0) {in.close(); in.clear(); in.open(s_File.c_str());}
+ else if(MureDataVersion<0) {OutputLog << "Old version of MURE... Check!!! exit(1)"; exit(0);}
+
+ // Read out the TIME the KEFF and the KEFF ERROR
+ double Time,Keff,Keff_Err;
+ in>>Time>>Keff>>Keff_Err;
+ in>>NumberOfCells;
+
+ // --------------------------- TIME ----------------------
+ vTime.push_back(Time);
+ vKeff.push_back(Keff);
+
+ bool STOP2READ=false;
+
+ for(int c=0 ; c<NumberOfCells; c++)
+ {
+ if(STOP2READ)break;
+ int CellNumber;
+ double Volume,Flux,FluxErr;
+ in>>CellNumber>>Volume>>Flux>>FluxErr;
+
+ vFlux.push_back(Flux);
+
+ int NNucleusRecords;
+ in>>NNucleusRecords;
+
+ // read the Cell Comment and Spatial Variables
+ string TheComment;
+ getline(in,TheComment); // the "in>>" command keep the cursor at the end of line
+ getline(in,TheComment); // so two "getline" commands are requested
+
+ bool SkipCell=false;
+ if(CellNumber<0 && TheComment!="WasteStorage") SkipCell=true;
+ if(TheComment=="WasteStorage") STOP2READ=true;
+
+ if (t==0)
+ {
+ vCellNumber.push_back(CellNumber);
+ vCellComment.push_back(TheComment);
+ }
+
+ int NSpatialVariables;
+ in>>NSpatialVariables;
+
+ vector<double> SpatialVariables;
+ vector<string> SpatialVariableNames;
+
+ for(int j=0; j<NSpatialVariables; j++)
+ {
+ string TheString;
+ double val;
+ in>>TheString>>val;
+ SpatialVariableNames.push_back(TheString);
+ SpatialVariables.push_back(val);
+ }
+
+ for(int i=0; i<NNucleusRecords; i++)
+ {
+ // Read the Nucleus Record
+ int Z,A,I;
+ double Mass,Proportion;
+ in>>Z>>A>>I>>Mass>>Proportion;
+ cout << Z << endl;
+ if(!SkipCell)
+ {
+ ZAI zai(Z, A, I, Proportion);
+ zai1.push_back(zai);
+ }
+
+ int NReactionRecords;
+ in>>NReactionRecords;
+ for (int k=0; k<NReactionRecords; k++)
+ {
+ int Code;
+ double Sigma,SigmaErr;
+ in>>Code>>Sigma>>SigmaErr;
+ if(!SkipCell)
+ {
+ ZAI zai(Z, A, I, Proportion);
+ if (Code==18) zai_FS_1.push_back(zai);
+ if (Code==102) zai_SC_1.push_back(zai);
+ if (Code==16) zai_SN_1.push_back(zai);
+
+ }
+
+ if(Sigma==0.0) Sigma=1e-10;
+ }
+
+
+
+
+ }
+ if(!SkipCell)
+ {
+ zai2.push_back(zai1);
+ zai1.clear();
+ zai_FS_2.push_back(zai_FS_1);
+ zai_FS_1.clear();
+ zai_SC_2.push_back(zai_SC_1);
+ zai_SC_1.clear();
+ zai_SN_2.push_back(zai_SN_1);
+ zai_SN_1.clear();
+ }
+ }
+ in.close();
+ zai3.push_back(zai2); zai2.clear();
+ zai_FS_3.push_back(zai_FS_2); zai_FS_2.clear();
+ zai_SC_3.push_back(zai_SC_2); zai_SC_2.clear();
+ zai_SN_3.push_back(zai_SN_2); zai_SN_2.clear();
+ vFlux1.push_back(vFlux); vFlux.clear();
+
+
+ }
+ // else ERROR
+ else {OutputLog << endl << "DATA files are neither binary nor ASCII?? ... EXIT!" << endl; exit(1);}
+ }
+ OutputLog << endl << "Last file read : " << LastDataFile << endl << endl;
+ OutputLog << "All (B)DATA files have been read..." << endl << endl;
+ OutputLog << "---------------------------------------------------" << endl;
+ OutputLog << "===================================================" << endl;
+
+ // =========================================================================================
+ // Manage several Cells
+ // =========================================================================================
+
+ // Time bins
+ int Nt = zai3.size();
+ // Number of cells
+ int Nc = zai3[0].size();
+
+ // Number of nuclides
+ int Ni = zai3[0][0].size();
+
+ double CycleTime = (vTime[vTime.size()-1] - vTime[0]) / 3600. / 24 / 365.4;
+
+ // Manage the cells...
+ bool SumOfCell = false;
+
+ if (vCellNumber.size()>=2)
+ {
+ OutputLog << endl << "===================================================" << endl;
+ OutputLog << "-------------- WARNING ----------------------------" << endl;
+ OutputLog << "===================================================" << endl << endl;
+ OutputLog << "THERE IS MORE THAN ONE CELL... Cells are : " << endl << endl; /*sleep(1)*/;
+ for(int i=0; i<vCellNumber.size(); i++)
+ {
+ OutputLog << "index : " << i << " - Cell number : " << vCellNumber[i] << endl;
+ OutputLog << "Cell comment : " << vCellComment[i] << endl << endl;
+ }
+ if(WantedCell==0) SumOfCell = true;
+
+ if (!SumOfCell && WantedCell>Nc) {OutputLog << "The index you choose is not defined... EXIT!" << endl; exit(1);}
+
+ zai2.clear();
+ zai_FS_2.clear();
+ zai_SC_2.clear();
+ zai_SN_2.clear();
+ vFlux.clear();
+ for (int t=0; t<Nt; t++)
+ {
+ for (int i=0; i<Ni; i++)
+ {
+ double SUM = 0;
+ for (int c=0; c<Nc; c++) SUM += zai3[t][c][i].Prop();
+ ZAI zai(zai3[t][0][i].Z(),zai3[t][0][i].A(),zai3[t][0][i].I(),SUM);
+ zai1.push_back(zai);
+ }
+ for (int i=0; i<(int)zai_FS_3[0][0].size(); i++)
+ {
+ double SUM = 0;
+ for (int c=0; c<Nc; c++) SUM += zai_FS_3[t][c][i].Prop()/Nc;
+ ZAI zai(zai_FS_3[t][0][i].Z(),zai_FS_3[t][0][i].A(),zai_FS_3[t][0][i].I(),SUM);
+ zai_FS_1.push_back(zai);
+ }
+ for (int i=0; i<(int)zai_SC_3[0][0].size(); i++)
+ {
+ double SUM = 0;
+ for (int c=0; c<Nc; c++) SUM += zai_SC_3[t][c][i].Prop()/Nc;
+ ZAI zai(zai_SC_3[t][0][i].Z(),zai_SC_3[t][0][i].A(),zai_SC_3[t][0][i].I(),SUM);
+ zai_SC_1.push_back(zai);
+ }
+ for (int i=0; i<(int)zai_SN_3[0][0].size(); i++)
+ {
+ double SUM = 0;
+ for (int c=0; c<Nc; c++) SUM += zai_SN_3[t][c][i].Prop()/Nc;
+ ZAI zai(zai_SN_3[t][0][i].Z(),zai_SN_3[t][0][i].A(),zai_SN_3[t][0][i].I(),SUM);
+ zai_SN_1.push_back(zai);
+ }
+
+ double SUM = 0;
+ for (int j=0; j<(int)vFlux1[t].size(); j++) SUM += vFlux1[t][j];
+
+ vFlux.push_back(SUM);
+
+ zai2.push_back(zai1);
+ zai1.clear();
+ zai_FS_2.push_back(zai_FS_1);
+ zai_FS_1.clear();
+ zai_SC_2.push_back(zai_SC_1);
+ zai_SC_1.clear();
+ zai_SN_2.push_back(zai_SN_1);
+ zai_SN_1.clear();
+
+ }
+ OutputLog << endl << "---------------------------------------------------" << endl;
+ OutputLog << "-------------- Sum of cells done ------------------" << endl;
+ OutputLog << "---------------------------------------------------" << endl << endl;
+ }
+ else WantedCell=0;
+
+
+ // =========================================================================================
+ // Manage the cutoff and calculate total N and M at t=0
+ // =========================================================================================
+
+ double NTotal = 0;
+ double MTotalFissile = 0;
+ if (SumOfCell)
+ {
+ for (int i=0; i<Ni; i++)
+ {
+ double Ni = zai2[0][i].Prop();
+ NTotal += Ni;
+ if (zai2[0][i].Z()>=90) MTotalFissile += Ni*zai2[0][i].A()/6.023e23;
+ }
+ }
+ else
+ {
+ for (int i=0; i<Ni; i++)
+ {
+ double Ni = zai3[0][WantedCell][i].Prop();
+ NTotal += Ni;
+ if (zai3[0][WantedCell][i].Z()>=90) MTotalFissile += Ni*zai3[0][WantedCell][i].A()/6.023e23;
+ }
+ }
+
+ // =========================================================================================
+ // Write the DATABASE and convert Number to Mass - Manage Normalization Factor
+ // =========================================================================================
+
+ ofstream Output(OutDataFile.c_str());
+ Output.precision(16);
+ Output << "time";
+ for(int t=StepToSkip; t<vTime.size(); t++) Output << " " << vTime.at(t)-vTime.at(StepToSkip);
+ Output << endl;
+
+ Output << "keff";
+ for(int t=StepToSkip; t<vKeff.size(); t++) Output << " " << vKeff.at(t);
+ Output << endl;
+
+ Output << "flux";
+ if (SumOfCell)
+ {
+ for(int t=StepToSkip; t<vTime.size(); t++) Output << " " << vFlux.at(t);
+ Output << endl;
+ }
+ else
+ {
+ for(int t=StepToSkip; t<vTime.size(); t++) Output << " " << vFlux1[t][WantedCell];
+ Output << endl;
+ }
+ int NPrinted=0;
+ {
+ if (SumOfCell)
+ {
+ for(int i=0; i < zai2[0].size(); i++)
+ {
+ Output << "Inv " << zai2[0][i].Z() << " " << zai2[0][i].A() << " " << zai2[0][i].I() << " ";
+ for (int t=StepToSkip; t<vTime.size(); t++)
+ {
+ double Val = zai2[t][i].Prop() * NormalizationFactor;
+ Output << Val << " ";
+ if (t==StepToSkip) NPrinted++;
+
+ }
+ Output << endl;
+ }
+ }
+ else
+ {
+ for(int i=0; i < zai3[0].size(); i++)
+ {
+ Output << "Inv " << zai3[0][0][i].Z() << " " << zai3[0][0][i].A() << " " << zai3[0][0][i].I() << " ";
+ for (int t=StepToSkip; t<vTime.size(); t++)
+ {
+ double Val = zai3[t][WantedCell][i].Prop() * NormalizationFactor;
+ Output << Val << " ";
+ if (t==StepToSkip) NPrinted++;
+ }
+ Output << endl;
+ }
+ }
+ }
+
+ if (SumOfCell)
+ {
+ for(int i=0; i< (int)zai_FS_2[0].size(); i++)
+ {
+
+ Output << "XSFis " << zai_FS_2[0][i].Z() << " " << zai_FS_2[0][i].A() << " " << zai_FS_2[0][i].I() << " ";
+ for (int t=StepToSkip; t<vTime.size(); t++)
+ {
+ double Val = zai_FS_2[t][i].Prop();
+ Output << Val << " ";
+
+ }
+ Output << endl;
+ }
+ }
+ else
+ {
+ for(int i=0; i< (int)zai_FS_3[0][0].size(); i++)
+ {
+
+ Output << "XSFis " << zai_FS_3[0][0][i].Z() << " " << zai_FS_3[0][0][i].A() << " " << zai_FS_3[0][0][i].I() << " ";
+ for (int t=StepToSkip; t<vTime.size(); t++)
+ {
+ double Val = zai_FS_3[t][WantedCell][i].Prop();
+ Output << Val << " ";
+ }
+ Output << endl;
+ }
+ }
+
+ if (SumOfCell)
+ {
+ for(int i=0; i< (int)zai_SC_2[0].size(); i++)
+ {
+ Output << "XSCap " << zai_SC_2[0][i].Z() << " " << zai_SC_2[0][i].A() << " " << zai_SC_2[0][i].I() << " ";
+ for (int t=StepToSkip; t<vTime.size(); t++)
+ {
+ double Val = zai_SC_2[t][i].Prop();
+ Output << Val << " ";
+
+ }
+ Output << endl;
+ }
+ }
+ else
+ {
+ for(int i=0; i< (int)zai_SC_3[0][0].size(); i++)
+ {
+ Output << "XSCap " << zai_SC_3[0][0][i].Z() << " " << zai_SC_3[0][0][i].A() << " " << zai_SC_3[0][0][i].I() << " ";
+ for (int t=StepToSkip; t<vTime.size(); t++)
+ {
+ double Val = zai_SC_3[t][WantedCell][i].Prop();
+ Output << Val << " ";
+ }
+ Output << endl;
+ }
+ }
+
+ if (SumOfCell)
+ {
+ for(int i=0; i< (int)zai_SN_2[0].size(); i++)
+ {
+ Output << "XSn2n " << zai_SN_2[0][i].Z() << " " << zai_SN_2[0][i].A() << " " << zai_SN_2[0][i].I() << " ";
+ for (int t=StepToSkip; t<vTime.size(); t++)
+ {
+ double Val = zai_SN_2[t][i].Prop();
+ Output << Val << " ";
+
+ }
+ Output << endl;
+ }
+ }
+ else
+ {
+ for(int i=0; i< (int)zai_SN_3[0][0].size(); i++)
+ {
+ Output << "XSn2n " << zai_SN_3[0][0][i].Z() << " " << zai_SN_3[0][0][i].A() << " " << zai_SN_3[0][0][i].I() << " ";
+ for (int t=StepToSkip; t<vTime.size(); t++)
+ {
+ double Val = zai_SN_3[t][WantedCell][i].Prop();
+ Output << Val << " ";
+ }
+ Output << endl;
+ }
+ }
+ Output.close();
+
+ ofstream OutputInfo(OutDataFileInfo.c_str());
+ OutputInfo << "Reactor " << ReactorType << endl;
+ OutputInfo << "Fueltype " << FuelType << endl;
+ OutputInfo << "CycleTime " << CycleTime << endl;
+ OutputInfo << "AssemblyHeavyMetalMass " << MTotalFissile << " g" << endl;
+ OutputInfo << "ConstantPower " << Power << " W" << endl;
+
+ OutputInfo << "Nnuclei " << NPrinted << endl;
+ OutputInfo << "NormalizationFactor " << NormalizationFactor << endl;
+ OutputInfo << "FinalHeavyMetalMass " << MTotalFissile*NormalizationFactor << " g" << endl;
+
+ OutputInfo.close();
+
+ // =========================================================================================
+ // BYE!
+ // =========================================================================================
+
+ OutputLog << "===================================================" << endl;
+ OutputLog << "---------------------------------------------------" << endl;
+
+ OutputLog << endl << "The database " << OutDataFile << " has been generated..." << endl;
+ OutputLog << "The database information " << OutDataFileInfo << " has been generated..." << endl << endl;
+ OutputLog << NPrinted << " nuclides have been written" << endl << endl;
+
+ OutputLog << "---------------------------------------------------" << endl;
+ OutputLog << "===================================================" << endl;
+
+}
+
+
+/*
+ g++ -o MURE2CLASS MURE2CLASS.cxx
+ */
diff --git a/Utils/trunk/MURE2CLASS/StringLine.hxx b/Utils/trunk/MURE2CLASS/StringLine.hxx
new file mode 100644
index 0000000000000000000000000000000000000000..17cbf14eba41348a89963438a23f813536920db0
--- /dev/null
+++ b/Utils/trunk/MURE2CLASS/StringLine.hxx
@@ -0,0 +1,275 @@
+#ifndef _STRINGLINE_
+#define _STRINGLINE_
+
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <algorithm>
+#include <cctype>
+using namespace std;
+/*!
+ \file
+ \brief Header file for StingLine class.
+*/
+
+//! Class extracting fields from a string / line.
+/*!
+ The aim of this class is to provide tools to extract fields ("word") from
+ a string and convert a string in Upper/Lower case.
+ All methods are static so that it is not necessary to create object to use them
+
+ example:
+ \code
+ string line="The temperature is : 300.6 K";
+ int start;
+
+ 1st method: creation of StringLine
+
+ start=0;
+ StringLine SL;
+ string the=SL.NextWord(line,start);
+ string temperature_is=SL.NextWord(line,start,':');
+ string colon=SL.NextWord(line,start);
+ double T=atof(SL.NextWord(line,start).c_str());
+ cout<<the<<endl<<temperature_is<<endl<<T<<endl;
+
+ 2nd method: "using" the static methods
+
+ start=0;
+ the=StringLine::NextWord(line,start);
+ temperature_is=StringLine::NextWord(line,start,':');
+ colon=StringLine::NextWord(line,start);
+ T=atof(StringLine::NextWord(line,start).c_str());
+ cout<<the<<endl<<temperature_is<<endl<<T<<endl;
+ \endcode
+ @author PTO
+ @version 2.01
+*/
+
+class StringLine
+{
+ public:
+ //! Find the next word in a line.
+ /*!
+ Find Next word in a line starting from position "start" in the line. If an alternative
+ separator is given, the word length is defined by the first position of sep or alt_sep found.
+ The first value of start is in general 0 (i.e. the beginning of the Line)
+ \param Line : a line containing words
+ \param start : from where to start to find the begining of a word
+ \param sep : the separator between 2 words (default=space)
+ \param alt_sep : the alternative separator between 2 words (default='')
+ */
+ static string NextWord(string Line,int &start,char sep=' ', char alt_sep='\0');
+ //! Find the previous word in a line.
+ /*!
+ Find Previous word in a line starting from position "start" in the line. If an alternative
+ separator is given, the word length is defined by the first position of sep or alt_sep found.
+ The first value of start is in general the end of the Line.
+ \param Line : a line containing words
+ \param start : from where to start to find the begining of a word
+ \param sep : the separator between 2 words (default=space)
+ \param alt_sep : the alternative separator between 2 words (default='')
+ */
+ static string PreviousWord(string Line,int &start,char sep=' ', char alt_sep='\0');
+ static void ToLower(string &Line); //!< convert a string to Lower case
+ static void ToUpper(string &Line); //!< convert a string to Upper case
+
+ //! Find \p search in \p Line from the begining.
+ /*!
+ returns the position, starting from the begenning of the first occurence
+ of \p search in \p Line if it is found, else returns -1
+ \param search : a string to find
+ \param Line : where to search
+ */
+ static int Find(const char *search,string Line);
+ //! Find \p search in \p Line from the end.
+ /*!
+ returns the position, starting from the end of the first occurence
+ of \p search in \p Line if it is found, else returns -1
+ \param search : a string to find
+ \param Line : where to search
+ */
+ static int rFind(const char *search,string Line);
+ //! convert a input type (\p in_T) to another (\p out_T).
+ /*!
+ Example:
+ \code
+ string s="32.12";
+ double t=StringLine::convert<double>(s);
+ string temperature=StringLine::convert<string>(300.);
+ \endcode
+ \param t : the input value
+ */
+ template <class out_T, class in_T> static out_T convert(const in_T & t);
+ //! Find the start of a word in a line.
+ /*!
+ \param Line : a line containing words
+ \param CurrentPosition : from where to start to find the begining of a word
+ \param sep : the separator between 2 words (default=space)
+ \param alt_sep : the alternative separator between 2 words (default='')
+ */
+ static int GetStartWord(string Line,int CurrentPosition,char sep=' ', char alt_sep='\0');
+ //! Find the end of a word in a line.
+ /*!
+ \param Line : a line containing words
+ \param CurrentPosition : from where to start to find the end of a word
+ \param sep : the separator between 2 words (default=space)
+ \param alt_sep : the alternative separator between 2 words (default='')
+ */
+ static int GetEndWord(string Line,int CurrentPosition,char sep=' ', char alt_sep='\0');
+ //! Replace a sub-string by an other in a string.
+ /*!
+ \param InLine : the string which contains the sub-string to replace
+ \param ToReplace : the sub-string to replace
+ \param By : the sub-string ToReplace is replaced by the sub-string By in Inline
+ */
+ static string ReplaceAll(string InLine, string ToReplace, string By);
+};
+
+
+//_________________________________________________________________________________
+inline string StringLine::NextWord(string Line,int &start,char sep, char alt_sep)
+{
+ string Word="";
+ if(start>=int(Line.size()))
+ {
+ return Word;
+ }
+ start=GetStartWord(Line,start,sep,alt_sep);
+ int wordlength=GetEndWord(Line,start,sep,alt_sep)-start;
+
+ Word=Line.substr(start,wordlength);
+
+ start+=wordlength;
+ return Word;
+}
+//_________________________________________________________________________________
+inline string StringLine::PreviousWord(string Line,int &start,char sep, char alt_sep)
+{
+ string Word="";
+ if(start<=0)
+ {
+ return Word;
+ }
+ int pos=Line.rfind(sep,start);
+ int alt_pos=-1;
+ int real_pos=pos;
+ char real_sep=sep;
+ if(alt_sep!='\0')
+ {
+ alt_pos=Line.rfind(alt_sep,start);
+ real_pos=max(pos,alt_pos);
+ if(real_pos!=pos)
+ real_sep=alt_sep;
+ }
+ int wordlength=start-Line.rfind(real_sep,real_pos);
+ if(real_pos<=0)
+ {
+ Word=Line.substr(0,start+1);
+ start=0;
+ return Word;
+ }
+ Word=Line.substr(real_pos+1,wordlength);
+
+ start-=wordlength+1;
+ return Word;
+}
+
+//_________________________________________________________________________________
+inline void StringLine::ToLower(string &Line)
+{
+ transform (Line.begin(), Line.end(), // source
+ Line.begin(), // destination
+ (int(*)(int))tolower); // operation
+}
+
+//_________________________________________________________________________________
+inline void StringLine::ToUpper(string &Line)
+{
+ transform (Line.begin(), Line.end(), // source
+ Line.begin(), // destination
+ (int(*)(int))toupper); // operation
+}
+
+//_________________________________________________________________________________
+inline int StringLine::GetStartWord(string Line,int CurrentPosition,char sep, char alt_sep)
+{
+ int pos=Line.find(sep,CurrentPosition);
+ int alt_pos=-1;
+ if(alt_sep!='\0')
+ alt_pos=Line.find(alt_sep,CurrentPosition);
+ int real_pos=pos;
+ char real_sep=sep;
+ if(alt_pos>=0)
+ {
+ real_pos=min(pos,alt_pos);
+ if(pos==int(string::npos))real_pos=alt_pos;
+ if(real_pos!=pos)
+ real_sep=alt_sep;
+ }
+ if(real_pos==int(string::npos)) return CurrentPosition;
+ while(CurrentPosition<int(Line.size()) && Line[CurrentPosition]==real_sep)
+ CurrentPosition++;
+ return CurrentPosition;
+}
+
+//_________________________________________________________________________________
+inline int StringLine::GetEndWord(string Line,int CurrentPosition,char sep, char alt_sep)
+{
+ int pos=Line.find(sep,CurrentPosition);
+ int alt_pos=-1;
+ if(alt_sep!='\0')
+ alt_pos=Line.find(alt_sep,CurrentPosition);
+ int real_pos=pos;
+ if(alt_pos>=0)
+ {
+ real_pos=min(pos,alt_pos);
+ if(pos==int(string::npos))real_pos=alt_pos;
+ }
+ if(real_pos==int(string::npos))
+ return Line.size();
+ return real_pos;
+}
+
+//_________________________________________________________________________________
+inline int StringLine::Find(const char *search,string Line)
+{
+ size_t Pos=Line.find(search);
+ if(Pos != string::npos ) return Pos;
+ return -1;
+}
+
+//_________________________________________________________________________________
+inline int StringLine::rFind(const char *search,string Line)
+{
+ size_t Pos=Line.rfind(search);
+ if(Pos != string::npos) return Pos;
+ return -1;
+}
+
+//_________________________________________________________________________________
+template <class out_T, class in_T>
+inline out_T StringLine::convert(const in_T & t)
+{
+ stringstream stream;
+ stream << t; // insert value to stream
+ out_T result; // store conversion's result here
+ stream >> result; // write value to result
+ return result;
+}
+
+//_________________________________________________________________________________
+inline string StringLine::ReplaceAll(string InLine, string ToReplace, string By)
+{
+ int start=0;
+ int pos=InLine.find(ToReplace,start);
+ while(pos!=int(string::npos))
+ {
+ InLine.replace(pos,ToReplace.size(),By);
+ start=0;
+ pos=InLine.find(ToReplace,start);
+ }
+ return InLine;
+
+}
+#endif
diff --git a/Utils/trunk/MURE2CLASS/ZAI.hxx b/Utils/trunk/MURE2CLASS/ZAI.hxx
new file mode 100644
index 0000000000000000000000000000000000000000..ad18e96528b42dac925148393746d8ad264ad256
--- /dev/null
+++ b/Utils/trunk/MURE2CLASS/ZAI.hxx
@@ -0,0 +1,50 @@
+#ifndef _ZAI_
+#define _ZAI_
+
+#include <math.h>
+#include <vector>
+#include <iostream>
+#include <string>
+using namespace std;
+
+class ZAI
+{
+ public:
+
+ ZAI() {fZ=0;fA=0;fI=0;fProp=0;fHalfLifeTime=0;} //!< Default constructor
+ ZAI(int Z, int A, int I) {fZ=Z;fA=A;fI=I;fProp=0.0;fHalfLifeTime=0;}
+ ZAI(int Z, int A, int I, double Prop) {fZ=Z;fA=A;fI=I;fProp=Prop;fHalfLifeTime=0;}
+// ~ZAI();
+
+
+ int Z(){return fZ;} //!< returns the number of protons
+ int A(){return fA;} //!< returns the number of nucleons
+ int I(){return fI;} //!< returns the Isomeric state (Ground State, ith excited)
+ int N(){return fA-fZ;} //!< returns the number of neutrons
+ double Prop(){return fProp;}//!< get the proportion of a ZAI
+
+ void Set(int Z, int A, int I, double p) {fZ=Z;fA=A;fI=I;fProp=p;}
+ void SetZ(int Z){fZ=Z;} //!< Set the proton number
+ void SetA(int A){fA=A;} //!< Set the nucleon number
+ void SetI(int I){fI=I;} //!< Set the isomeric state (0=gs,...)
+ void SetProp(double p){fProp=p;}//!< set the proportion of a ZAI
+
+ void SetHalfLifeTime(double T_12){fHalfLifeTime=T_12;} //!< Set the Decay Half life [s]
+ double GetHalfLifeTime(){return fHalfLifeTime;} //!< returns the Decay Half life [s]
+ void SetDecayConstant(double lambda){fHalfLifeTime=log(2.)/lambda;} //!< Set the Decay Constant
+ double GetDecayConstant(){if (fHalfLifeTime)return log(2.)/fHalfLifeTime;return 0.;} //!< returns the Decay Half life
+
+ void Stable(){fStable=true;} //!< Set that a ZAI is stable to decay
+ bool IsStable(){return fStable;}//!< Return whether a ZAI is stable
+
+ protected:
+
+ int fZ; //!< number of protons
+ int fA; //!< number of nucleons (A=0 means natural isotopes)
+ int fI; //!< Isomeric state (Ground State, ith excited)
+ double fProp; //!< Mass of a ZAI (from the BaseSummary.dat file
+ double fHalfLifeTime; //!< Decay Half life constant
+ bool fStable; //!< whether a ZAI is stable
+
+};
+#endif
diff --git a/Utils/trunk/README_FOR_CLASS b/Utils/trunk/README_FOR_CLASS
deleted file mode 100644
index 8570d63bbeff9eeee165145353431e139e3a0e5e..0000000000000000000000000000000000000000
--- a/Utils/trunk/README_FOR_CLASS
+++ /dev/null
@@ -1,165 +0,0 @@
-/**************************************************************************/
-/* */
-/* */
-/* CLASS version 2.0 */
-/* Installation procedure and FAQ */
-/* 04/06/2013 */
-/* */
-/**************************************************************************/
-CLASS development team:
- - B. Mouginot, Subatech Nantes
- - M. Ernoult, IPN Orsay
-
-CLASS development team can be joined through https://forge.in2p3.fr/projects/classforge
-
-----------------------------
-CLASS GENERAL PRESENTATION :
-----------------------------
-CLASS stand for Core Library for Advanced Scenario Simulation.
-The nuclear reactor simulation community has a requirement to perform complex electro-nuclear scenario simulation. To avoid constraints coming from existing powerful scenario software as COSI, VISION or FAMILY, the open source Core Library for Advance Scenario Simulation (CLASS) is being developed.
-CLASS main asset is its ability to include any kind of reactor, whether the system is innovative or standard. A reactor is fully described by its evolution database that should contain a set of different validated fuel compositions in order to simulate transitional scenarios. CLASS aims to be a useful tool to study scenarios involving Generation IV reactors as well as innovative fuel cycles, like the Thorium cycle.
-
---------------
-REQUIREMENTS :
---------------
-In order to be able to use CLASS, you need :
-- a Computer able of compiling C++ code (It native on Linux, for Mac OS need to install "Xcode develloper Tools", for Windows it need a specific installation but Visual C++ work and is free)
-- the root library (downloadable on http://root.cern.ch/drupal/)
-- an OpenMP library (often include inside the standard c++ libraries and compiler, more informations can be found on http://openmp.org/wp/)
-
---------------
-INSTALLATION :
---------------
-
---> Getting the Source <--
-Before the beginning of the installation you will need to recuperate some files.
-
-First, the sources of the CLASS package.
-A stable version is down-loadable on https://forge.in2p3.fr/projects/classforge/files. They are organized in 4 folder : Doxygen containing an html guide to all functions existing in the code; external for the libraries used by CLASS but not coded and maintained by the CLASS development team, include for the header of the CLASS objects and functions and src for the main code.
-
-Second, some Databank.
-At least a decay databank following the isotopes produced during the decay of radio-active elements. Reactors databanks will be needed for each reactor type and each fuel type you want to pout in your scenarios.
-
-Third, rootlogon.C and read.C root macros.
-These two are not essential to run CLASS but allow a much simpler view of the result of CLASS simulations.
-
-When you have all the source, the recommended way is to unpack all of them in a CLASS folder, in order to have a organization like :
------------------------------------------
-| CLASS\ |
-| -\DataBase\ |
-| -\Decay\ |
-| -\DB1\ |
-| -\DB2\ |
-| -\... |
-| -Decay.idx |
-| -DB1.idx |
-| -... |
-| -\source\ |
-| -\Doxygen\ |
-| -\external\ |
-| -\include\ |
-| -\src\ |
-| -Doxyfile |
-| -\Utils\ |
-| -read.C |
-| -Example_CLASS.cpp |
------------------------------------------
-
---> Setting the environment variables <--
-
-If you are using a bash terminal, add to our /home/perso/.bashrc :
- export CLASS_PATH=/your/way/to/CLASS
- export CLASS_include=$CLASS_PATH/source/include
- export CLASS_lib=$CLASS_PATH/lib
- export LD_LIBRARY_PATH=$CLASS_lib:$LD_LIBRARY_PATH
-
-If you are using a tcsh, add to /home/perso/.tcshrc :
- setenv CLASS_PATH Your_way_to_CLASS
- setenv CLASS_include $CLASS_PATH/source/include
- setenv CLASS_lib $CLASS_PATH/lib
- setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:$CLASS_lib
-
-Make the lib and the utils folder in your CLASS path :
- mkdir $CLASS_PATH/lib
-Copy rootlogon.C in your home.
- cp rootlogon.C /home/perso/.rootlogon.C
-
---> Compiling the code <--
-To compile the code, you have to go on the CLASS source folder :
- cd $CLASS_PATH/source/src
-In order to be sure that no old version of class remain in the same folder, clean it :
- make clean
-Finnaly compile the code. If you have several core available you can use N of them, by using the command :
- make -j N
-
-You should see many compilation line and à the end, check that the two main package have been created :
-...
-libCLASSpkg.so done
-...
-libCLASSpkg_root.so done
-If it is so, CLASS is compile and ready to use.
-
---> Linking the DataBase <--
-Before running any simulation, you have to check that the *.idx file of the databanks give the right path for the *.dat files.
-So open your *.idx file.
-It should be many line like this :
-/home/perso/DataBase/........dat
-Change the /home/perso/ part in order to match with your installation folder.
-
---> Running The Example <--
-For the test, you should have an example file named : Example_CLASS.cpp.
-Move the example file to your CLASS_PATH :
- mv Example_CLASS.cpp $CLASS_PATH/
-Go to the CLASS_PATH :
- cd $CLASS_PATH
-Open it and change the path to the databank to match your installation scheme.
-Use the following line to compile the program :
- g++ -o CLASS_exec Example_CLASS.cpp -I $CLASS_include -L $CLASS_lib -lCLASSpkg `root-config --cflags` `root-config --libs` -fopenmp -lgomp -Wunused-result
-Then run :
- ./CLASS_exec
-You should have a nice progression bar like :
-[||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||-] Processed 100 / 100 Years
-The progress bar represent the progression through the time inside the simulated scenario not the progression through the calcul time.
-The calculation needed at each time is not constant, so the progression of the bar can be really irregular.
-
-Before leaving, the executable should write :
- ...
- Writing outTree CLASS_Default.root
- Deleting outTree :
- Closing file : CLASS_Default.root
-If it's the case, then all is OK.
-
---> Reading the results <--
-If you have correctly installed the .rootlogon.C and the Read.C, it is really easy, jute type :
-root CLASS_Default.root
-IT should open root. In the root console, you have access to many functions.
-To have the graph of the quantity of a isotope in some place of your scenario, you just have to write :
-read(Data, "MyObservable", Z, A, I)
-Where Z, A and I characterize the wanted isotope. MyObservable is the place when the bilan is made, it can have the following values :
- STOCK
- FUELFABRICATION
- COOLING
- INCREACTOR
- INCYCLE
- TOTAL
- GODINCOME
- WASTE
-There are also specific functions for reading specific objects : ReadReactor, ReadFabrication, ReadCooling and ReadStorage. The description of these function and the complete list of the function can be found in Read.C.
-
-If you don't have installed the .rootlogon.C, you need to open root and after to write in the root console :
- #include "TMatrix"
- .L $CLASS_lib/libCLASSpkg_root.so
- .L $CLASS_PATH/read.C
- TFile *_file0 = TFile::Open("CLASS_Default.root")
-
-----------------------------
-FREQUENTLY ASKED QUESTIONS :
-----------------------------
-1. CLASS can't find my DataBank or some EvolutionData
- Can't open "/home/cramal/CLASS/DataBase/DB_42_45/DB.idx"
- !!Bad Trouble!! !!!DataBank!!! Bad Database file : /home/cramal/CLASS/DataBase/DB_42_45/DB.idx Can't find the type of the DataBase
-You have made a mistake in the path to your Databank index in your file.
-
- Can't open "DataBase/DB_42_45/Data/REPMOX_U_238_86.7282__Pu_238_0.138427_239_5.25615_240_2.94485_241_2.37377_242_2.20291__Am_241_0.355667.dat"
- !!Bad Trouble!! !!!EvolutionData!!! Bad Database file : DataBase/DB_42_45/Data/REPMOX_U_238_86.7282__Pu_238_0.138427_239_5.25615_240_2.94485_241_2.37377_242_2.20291__Am_241_0.355667.dat
-You have probably forgotten to change some path in your *.idx
diff --git a/Utils/trunk/rootlogon.C b/Utils/trunk/rootlogon.C
deleted file mode 100755
index 7c464fb1f322d6f11f33572365edb536615805ec..0000000000000000000000000000000000000000
--- a/Utils/trunk/rootlogon.C
+++ /dev/null
@@ -1,7 +0,0 @@
-{
- #include "TMatrix"
- gSystem.Load("$CLASS_lib/libCLASSpkg_root.so");
- gROOT.LoadMacro("$CLASS_PATH/Utils/read.C");
- gROOT.LoadMacro("$APP_PATH/RootMacro/Read.C");
-
-}