diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_BakerRoss_FBR_MOX.cxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_BakerRoss_MOX.cxx
similarity index 94%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_BakerRoss_FBR_MOX.cxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_BakerRoss_MOX.cxx
index 468500d445194dfec3a9b0ef80eec1057e30f7cf..604e1a8f2f89fc5ab294e1aeb71ac08ff994ad6b 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_BakerRoss_FBR_MOX.cxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_BakerRoss_MOX.cxx
@@ -1,11 +1,11 @@
-#include "EQM_BakerRoss_FBR_MOX.hxx"
+#include "EQM_FBR_BakerRoss_MOX.hxx"
#include "CLASSLogger.hxx"
#include <vector>
//________________________________________________________________________
//
-// EQM_BakerRoss_FBR_MOX
+// EQM_FBR_BakerRoss_MOX
//
// Equivalenve Model based on Plutonium 239 equivalent
// using the formula of Baker&Ross
@@ -13,7 +13,7 @@
//________________________________________________________________________
-EQM_BakerRoss_FBR_MOX::EQM_BakerRoss_FBR_MOX(double Weight_U_235, double Weight_Pu_238, double Weight_Pu_240, double Weight_Pu_241, double Weight_Pu_242, double Weight_Am_241, double EquivalentFissile):EquivalenceModel(new CLASSLogger("EQM_BakerRoss_FBR_MOX.log"))
+EQM_FBR_BakerRoss_MOX::EQM_FBR_BakerRoss_MOX(double Weight_U_235, double Weight_Pu_238, double Weight_Pu_240, double Weight_Pu_241, double Weight_Pu_242, double Weight_Am_241, double EquivalentFissile):EquivalenceModel(new CLASSLogger("EQM_FBR_BakerRoss_MOX.log"))
{
ZAI U8(92,238,0);
ZAI U5(92,235,0);
@@ -54,7 +54,7 @@ EQM_BakerRoss_FBR_MOX::EQM_BakerRoss_FBR_MOX(double Weight_U_235, double Weight_
}
//________________________________________________________________________
-EQM_BakerRoss_FBR_MOX::EQM_BakerRoss_FBR_MOX(CLASSLogger* log, double Weight_U_235, double Weight_Pu_238, double Weight_Pu_240, double Weight_Pu_241, double Weight_Pu_242, double Weight_Am_241, double EquivalentFissile ):EquivalenceModel(log)
+EQM_FBR_BakerRoss_MOX::EQM_FBR_BakerRoss_MOX(CLASSLogger* log, double Weight_U_235, double Weight_Pu_238, double Weight_Pu_240, double Weight_Pu_241, double Weight_Pu_242, double Weight_Am_241, double EquivalentFissile ):EquivalenceModel(log)
{
ZAI U8(92,238,0);
ZAI U5(92,235,0);
@@ -96,7 +96,7 @@ EQM_BakerRoss_FBR_MOX::EQM_BakerRoss_FBR_MOX(CLASSLogger* log, double Weight_U_2
}
//________________________________________________________________________
-double EQM_BakerRoss_FBR_MOX::GetFissileMolarFraction(IsotopicVector Fissile,IsotopicVector Fertile,double BurnUp)
+double EQM_FBR_BakerRoss_MOX::GetFissileMolarFraction(IsotopicVector Fissile,IsotopicVector Fertile,double BurnUp)
{
if(BurnUp != 0 )
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_BakerRoss_FBR_MOX.hxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_BakerRoss_MOX.hxx
similarity index 90%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_BakerRoss_FBR_MOX.hxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_BakerRoss_MOX.hxx
index f940bbcc0d8134db38785eda2d61c06aa671e83a..75eef5fd9ad2127965c079c65b3fdf8ee2b40c98 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_BakerRoss_FBR_MOX.hxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_BakerRoss_MOX.hxx
@@ -1,5 +1,5 @@
-#ifndef _EQM_BakerRoss_FBR_MOX_HXX
-#define _EQM_BakerRoss_FBR_MOX_HXX
+#ifndef _EQM_FBR_BakerRoss_MOX_HXX
+#define _EQM_FBR_BakerRoss_MOX_HXX
#include "EquivalenceModel.hxx"
@@ -7,7 +7,7 @@
/*!
\file
- \brief Header file for EQM_BakerRoss_FBR_MOX class.
+ \brief Header file for EQM_FBR_BakerRoss_MOX class.
@author BLG
@@ -39,7 +39,7 @@ using namespace std;
*/
//________________________________________________________________________
-class EQM_BakerRoss_FBR_MOX : public EquivalenceModel
+class EQM_FBR_BakerRoss_MOX : public EquivalenceModel
{
public :
@@ -51,7 +51,7 @@ class EQM_BakerRoss_FBR_MOX : public EquivalenceModel
/// Logger constructor
/*!
- Make a new EQM_BakerRoss_FBR_MOX : the default values have been calculated for a FBR-Na of type : ESFR like (without blanket)
+ Make a new EQM_FBR_BakerRoss_MOX : the default values have been calculated for a FBR-Na of type : ESFR like (without blanket)
\param log : use for the log
\param Weight_U_235 : reactivity weight @f$W_{^{235}U} = \frac{\alpha_{{^{235}U}} - \alpha_{^{238}U} }{\alpha_{^{239}Pu}-\alpha_{^{238}U}}@f$
\param Weight_Pu_238 : reactivity weight @f$W_{^{238}Pu} = \frac{\alpha_{{^{238}Pu}} - \alpha_{^{238}U} }{\alpha_{^{239}Pu}-\alpha_{^{238}U}}@f$
@@ -61,14 +61,14 @@ class EQM_BakerRoss_FBR_MOX : public EquivalenceModel
\param Weight_Am_241 : reactivity weight @f$W_{^{241}Pu} = \frac{\alpha_{{^{241}Am}} - \alpha_{^{238}U} }{\alpha_{^{239}Pu}-\alpha_{^{238}U}}@f$
\param EquivalentFissile : reference fresh fuel @f$^{239}Pu@f$ content neeed in a @f$^{238}U@f$ + @f$^{239}Pu@f$ fuel to satisfy criticality at t=0
*/
- EQM_BakerRoss_FBR_MOX(CLASSLogger* log, double Weight_U_235 = 0.791135, double Weight_Pu_238 = 0.686385, double Weight_Pu_240 = 0.13553, double Weight_Pu_241 = 1.54572 , double Weight_Pu_242 = 0.0829001, double Weight_Am_241 = -0.336945, double EquivalentFissile = 0.103213);
+ EQM_FBR_BakerRoss_MOX(CLASSLogger* log, double Weight_U_235 = 0.791135, double Weight_Pu_238 = 0.686385, double Weight_Pu_240 = 0.13553, double Weight_Pu_241 = 1.54572 , double Weight_Pu_242 = 0.0829001, double Weight_Am_241 = -0.336945, double EquivalentFissile = 0.103213);
//}
//{
/// normal constructor
/*!
- Make a new EQM_BakerRoss_FBR_MOX : the default values have been calculated for a FBR-Na of type : ESFR like (without blanket)
+ Make a new EQM_FBR_BakerRoss_MOX : the default values have been calculated for a FBR-Na of type : ESFR like (without blanket)
\param Weight_U_235 : reactivity weight @f$W_{^{235}U} = \frac{\alpha_{{^{235}U}} - \alpha_{^{238}U} }{\alpha_{^{239}Pu}-\alpha_{^{238}U}}@f$
\param Weight_Pu_238 : reactivity weight @f$W_{^{238}Pu} = \frac{\alpha_{{^{238}Pu}} - \alpha_{^{238}U} }{\alpha_{^{239}Pu}-\alpha_{^{238}U}}@f$
\param Weight_Pu_240 : reactivity weight @f$W_{^{240}Pu} = \frac{\alpha_{{^{240}Pu}} - \alpha_{^{238}U} }{\alpha_{^{239}Pu}-\alpha_{^{238}U}}@f$
@@ -77,7 +77,7 @@ class EQM_BakerRoss_FBR_MOX : public EquivalenceModel
\param Weight_Am_241 : reactivity weight @f$W_{^{241}Pu} = \frac{\alpha_{{^{241}Am}} - \alpha_{^{238}U} }{\alpha_{^{239}Pu}-\alpha_{^{238}U}}@f$
\param EquivalentFissile : reference fresh fuel @f$^{239}Pu@f$ content neeed in a @f$^{238}U@f$ + @f$^{239}Pu@f$ fuel to satisfy criticality at t=0
*/
- EQM_BakerRoss_FBR_MOX(double Weight_U_235 = 0.791135, double Weight_Pu_238 = 0.686385, double Weight_Pu_240 = 0.13553, double Weight_Pu_241 = 1.54572 , double Weight_Pu_242 = 0.0829001, double Weight_Am_241 = -0.336945, double EquivalentFissile = 0.103213);
+ EQM_FBR_BakerRoss_MOX(double Weight_U_235 = 0.791135, double Weight_Pu_238 = 0.686385, double Weight_Pu_240 = 0.13553, double Weight_Pu_241 = 1.54572 , double Weight_Pu_242 = 0.0829001, double Weight_Am_241 = -0.336945, double EquivalentFissile = 0.103213);
//}
//@}
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff.cxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..34ffa048a0ddbe98ea83d199363f22bf32a0fecd
--- /dev/null
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff.cxx
@@ -0,0 +1,396 @@
+#include "EQM_FBR_MLP_Keff.hxx"
+#include "CLASSLogger.hxx"
+#include "CLASSMethod.hxx"
+#include "StringLine.hxx"
+
+#include <string>
+#include <iostream>
+#include <fstream>
+#include <algorithm>
+#include <cmath>
+#include <cassert>
+#include <map>
+
+#include "TSystem.h"
+#include "TMVA/Reader.h"
+#include "TMVA/Tools.h"
+#include "TMVA/MethodCuts.h"
+
+//________________________________________________________________________
+//
+// EQM_FBR_MLP_Keff
+//
+// Equivalenve Model based on multi layer perceptron from TMVA (root cern)
+// For FBR
+//
+//________________________________________________________________________
+
+
+//________________________________________________________________________
+//
+// Objects & Methods for content prediction with calculation of Keff at
+// one given time (often BOC or EOC)
+//
+//________________________________________________________________________
+
+//________________________________________________________________________
+EQM_FBR_MLP_Keff::EQM_FBR_MLP_Keff(string TMVAWeightPath, double keff_target, string InformationFile):EquivalenceModel(new CLASSLogger("EQM_FBR_MLP_Keff.log"))
+{
+ fIsAverageKeff = false;
+
+ /**The tmva weight*/
+ fTMVAWeightPath = TMVAWeightPath;
+
+ fTargetKeff = keff_target;
+
+ if(InformationFile=="")
+ InformationFile = StringLine::ReplaceAll(TMVAWeightPath,".xml",".nfo");
+
+ fInformationFile = InformationFile;
+ GetModelInformation(); //Getting information from fMLPInformationFile
+
+ SetPCMprecision(10);
+ SetBuildFuelFirstGuess(0.15); //First fissile content guess for the EquivalenceModel::BuildFuel algorithm
+ fActualFissileContent = fFirstGuessFissilContent ;
+
+ INFO << "__An equivalence model has been define__"<<endl;
+ INFO << "\tThis model is based on the prediction of keff at a specific time"<<endl;
+ INFO << "\tThe TMVA (weight | information) files are :"<<endl;
+ INFO << "\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )"<<endl;
+
+}
+//________________________________________________________________________
+EQM_FBR_MLP_Keff::EQM_FBR_MLP_Keff(CLASSLogger* log, string TMVAWeightPath, double keff_target, string InformationFile):EquivalenceModel(log)
+{
+ fIsAverageKeff = false;
+
+ /**The tmva weight*/
+ fTMVAWeightPath = TMVAWeightPath;
+
+ fTargetKeff = keff_target;
+
+ if(InformationFile=="")
+ InformationFile = StringLine::ReplaceAll(TMVAWeightPath,".xml",".nfo");
+
+ fInformationFile = InformationFile;
+ GetModelInformation(); //Getting information from fMLPInformationFile
+
+ SetPCMprecision(10);
+ SetBuildFuelFirstGuess(0.15); //First fissile content guess for the EquivalenceModel::BuildFuel algorithm
+ fActualFissileContent = fFirstGuessFissilContent ;
+
+ INFO << "__An equivalence model has been define__"<<endl;
+ INFO << "\tThis model is based on the prediction of keff at a specific time"<<endl;
+ INFO << "\tThe TMVA (weight | information) files are :"<<endl;
+ INFO << "\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )"<<endl;
+
+}
+
+
+//________________________________________________________________________
+TTree* EQM_FBR_MLP_Keff::CreateTMVAInputTree(IsotopicVector TheFreshfuel, double ThisTime)
+{
+ /******Create Input data tree to be interpreted by TMVA::Reader***/
+ TTree* InputTree = new TTree("InTMPKef", "InTMPKef");
+
+ vector<float> InputTMVA;
+ for(int i = 0 ; i< (int)fMapOfTMVAVariableNames.size() ; i++)
+ InputTMVA.push_back(0);
+
+ float Time=0;
+
+ IsotopicVector IVInputTMVA;
+ map<ZAI ,string >::iterator it;
+ int j=0;
+
+ for( it = fMapOfTMVAVariableNames.begin() ; it!=fMapOfTMVAVariableNames.end() ; it++)
+ {
+ InputTree->Branch( ((*it).second).c_str() ,&InputTMVA[j], ((*it).second + "/F").c_str());
+ IVInputTMVA+= ((*it).first)*1;
+ j++;
+ }
+
+ if(ThisTime!=-1)
+ InputTree->Branch( "Time" ,&Time ,"Time/F" );
+
+ IsotopicVector IVAccordingToUserInfoFile = TheFreshfuel.GetThisComposition(IVInputTMVA);
+
+ double Ntot = IVAccordingToUserInfoFile.GetSumOfAll();
+
+ IVAccordingToUserInfoFile = IVAccordingToUserInfoFile/Ntot;
+
+ j=0;
+ map<ZAI ,string >::iterator it2;
+
+ for( it2 = fMapOfTMVAVariableNames.begin() ; it2!=fMapOfTMVAVariableNames.end() ; it2++)
+ {
+ InputTMVA[j] = IVAccordingToUserInfoFile.GetZAIIsotopicQuantity( (*it2).first ) ;
+ j++;
+ }
+
+ Time=ThisTime;
+
+ InputTree->Fill();
+
+ return InputTree;
+
+}
+//________________________________________________________________________
+double EQM_FBR_MLP_Keff::ExecuteTMVA(TTree* InputTree, bool IsTimeDependent)
+{
+
+ // --- Create the Reader object
+ TMVA::Reader *reader = new TMVA::Reader( "Silent" );
+
+ // Create a set of variables and declare them to the reader
+ // - the variable names MUST corresponds in name and type to those given in the weight file(s) used
+ vector<float> InputTMVA;
+ for(int i = 0 ; i< (int)fMapOfTMVAVariableNames.size() ; i++)
+ InputTMVA.push_back(0);
+ Float_t Time;
+
+ map<ZAI ,string >::iterator it;
+ int j=0;
+ for( it = fMapOfTMVAVariableNames.begin() ; it!=fMapOfTMVAVariableNames.end() ; it++)
+ { reader->AddVariable( ( (*it).second ).c_str(),&InputTMVA[j]);
+ j++;
+ }
+
+ if(IsTimeDependent)
+ reader->AddVariable( "Time" ,&Time);
+
+ // --- Book the MVA methods
+
+ // Book method MLP
+ TString methodName = "MLP method";
+ reader->BookMVA( methodName, fTMVAWeightPath );
+
+ map<ZAI ,string >::iterator it2;
+ j=0;
+ for( it2 = fMapOfTMVAVariableNames.begin() ; it2!=fMapOfTMVAVariableNames.end() ; it2++)
+ {
+ InputTree->SetBranchAddress(( (*it2).second ).c_str(),&InputTMVA[j]);
+ j++;
+ }
+
+ if(IsTimeDependent)
+ InputTree->SetBranchAddress( "Time" ,&Time );
+
+ InputTree->GetEntry(0);
+ Float_t val = (reader->EvaluateRegression( methodName ))[0];
+
+ delete reader;
+
+ return (double)val; //return k_{eff}(t=Time)
+}
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff::GetModelInformation()
+{
+DBGL
+}
+
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff::LoadKeyword()
+{
+ DBGL
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_timestep", & EQM_FBR_MLP_Keff::ReadTimeSteps));
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_specpower", & EQM_FBR_MLP_Keff::ReadSpecificPower));
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_contentmax", & EQM_FBR_MLP_Keff::ReadMaximalContent));
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_zainame", & EQM_FBR_MLP_Keff::ReadZAIName) );
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_fissil", & EQM_FBR_MLP_Keff::ReadFissil) );
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_fertil", & EQM_FBR_MLP_Keff::ReadFertil) );
+ DBGL
+}
+
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff::ReadZAIName(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_zainame" ) // Check the keyword
+ {
+ ERROR << " Bad keyword : \"k_zainame\" not found !" << endl;
+ exit(1);
+ }
+
+ int Z = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int A = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int I = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+
+ fFissileList.Add(Z, A, I, 1.0);
+
+ DBGL
+}
+
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff::ReadSpecificPower(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_specpower") // Check the keyword
+ {
+ ERROR << " Bad keyword : \"k_specpower\" Not found !" << endl;
+ exit(1);
+ }
+
+ fSpecificPower = atof(StringLine::NextWord(line, pos, ' ').c_str());
+
+ DBGL
+}
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff::ReadMaximalContent(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_contentmax") // Check the keyword
+ {
+ ERROR << " Bad keyword : \"k_contentmax\" Not found !" << endl;
+ exit(1);
+ }
+
+ fMaximalContent = atof(StringLine::NextWord(line, pos, ' ').c_str());
+
+ DBGL
+}
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff::ReadFissil(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_fissil" ) // Check the keyword
+ {
+ ERROR << " Bad keyword : \"k_fissil\" not found !" << endl;
+ exit(1);
+ }
+
+ int Z = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int A = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int I = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ double Q = atof(StringLine::NextWord(line, pos, ' ').c_str());
+
+ fFertileList.Add(Z, A, I, Q);
+
+ DBGL
+}
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff::ReadFertil(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_fertil" ) // Check the keyword
+ {
+ ERROR << " Bad keyword : \"k_fertil\" not found !" << endl;
+ exit(1);
+ }
+
+ int Z = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int A = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int I = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+
+ string name = StringLine::NextWord(line, pos, ' ');
+
+ fMapOfTMVAVariableNames.insert( pair<ZAI,string>( ZAI(Z, A, I), name ) );
+
+ DBGL
+}
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff::ReadTimeSteps(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_timestep" ) // Check the keyword
+ {
+ ERROR << " Bad keyword : \"k_timestep\" not found !" << endl;
+ exit(1);
+ }
+
+ while( pos < (int)line.size() )
+ fMLP_Time.push_back( atof( (StringLine::NextWord(line,pos,' ')).c_str() ));
+ DBGL
+}
+
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff::ReadLine(string line)
+{
+ DBGL
+
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+
+ map<string, MLP_FBR_Keff_DMthPtr>::iterator it = fDKeyword.find(keyword);
+
+ if(it != fDKeyword.end())
+ (this->*(it->second))( line );
+
+ DBGL
+}
+
+
+
+
+//________________________________________________________________________
+double EQM_FBR_MLP_Keff::GetFissileMolarFraction(IsotopicVector Fissile,IsotopicVector Fertile,double TargetBU)
+{
+ if(TargetBU != 0)
+ WARNING<<"The third arguement : Burnup has no effect here.";
+
+
+ //initialization
+ double FissileContent = GetActualFissileContent();
+ double OldFissileContentMinus = 0;
+ double OldFissileContentPlus = fMaximalContent;
+ double PredictedKeff = 0 ;
+ IsotopicVector FreshFuel = (1-FissileContent)*(Fertile/Fertile.GetSumOfAll()) + FissileContent*(Fissile/Fissile.GetSumOfAll());
+ double OldPredictedKeff = GetKeffAtFixedTime(FreshFuel);
+
+ double Precision = fPCMprecision/1e5*fTargetKeff; //pcm to 1
+
+ int count = 0;
+ int MaximumLoopCount = 100;
+ do
+ {
+ if(count > MaximumLoopCount )
+ {
+ ERROR << "CRITICAL ! Can't manage to predict fissile content\nHint : Try to decrease the precision on keff using :\nYourEQM_FBR_MLP_Keff->SetPCMPrecision(prop); with prop the precision (default 0.5percent : 0.005) INCREASE IT \n If this message still appear mail to leniau@subatech.in2p3.fr\nor nicolas.thiolliere@subatech.in2p3.fr "<<endl;
+ exit(1);
+ }
+
+ if( (OldPredictedKeff - fTargetKeff) < 0 ) //The Content can be increased
+ {
+ OldFissileContentMinus = FissileContent;
+ FissileContent = FissileContent + fabs(OldFissileContentPlus-FissileContent)/2.;
+ }
+ else if( (OldPredictedKeff - fTargetKeff) > 0) //The Content is too high
+ {
+ OldFissileContentPlus = FissileContent;
+ FissileContent = FissileContent - fabs(OldFissileContentMinus-FissileContent)/2.;
+ }
+
+ IsotopicVector FreshFuel = (1-FissileContent)*(Fertile/Fertile.GetSumOfAll()) + FissileContent*(Fissile/Fissile.GetSumOfAll());
+
+ PredictedKeff = GetKeffAtFixedTime(FreshFuel);
+
+ OldPredictedKeff = PredictedKeff;
+ count ++;
+
+ }while(fabs(fTargetKeff-PredictedKeff)>Precision);
+
+ DBGV( "Predicted keff "<<PredictedKeff<<" FissileContent "<<FissileContent<<endl);
+ return FissileContent;
+
+}
+//________________________________________________________________________
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Keff_FBR.hxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff.hxx
similarity index 62%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Keff_FBR.hxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff.hxx
index fa22af3eafc20a6f366c549984f9dac4cc1c9211..019e483eb7a642f123fdda76c8f0ea873772a736 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Keff_FBR.hxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff.hxx
@@ -1,13 +1,18 @@
-#ifndef _EQM_MLP_Keff_FBR_HXX
-#define _EQM_MLP_Keff_FBR_HXX
+#ifndef _EQM_FBR_MLP_Keff_HXX
+#define _EQM_FBR_MLP_Keff_HXX
#include "EquivalenceModel.hxx"
#include "TTree.h"
#include "TGraph.h"
+#include <string>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <vector>
/*!
\file
- \brief Header file for EQM_MLP_Keff_FBR class.
+ \brief Header file for EQM_FBR_MLP_Keff class.
@author BLG
@@ -24,19 +29,6 @@ The aim of these class is to constuct a fuel from an equivalence model
based on a Multi layer perceptron (MLP).
This MLP aims to predict either :
-Method 1 :
-
-The @f$k_{\infty}(t)@f$ of a FBR-MOX from a given fresh fuel composition.
-With this MLP prediction and a given number of batch (for the loading plan) an
-average @f$<k_{\infty}(t)>@f$ is calculated according :
-@f$<k_{\infty}>^{batch}(t) = \frac{1}{N}\sum_{i}^{N} k_{\infty}(t + \frac{iT}{N} )@f$
-The Fissile content has to verify this condition :
-@f$ k_{\infty Max} \geq <k_{\infty}>^{batch}(T/N) \geq k_{\infty Min} @f$
-Where @f$ k_{\infty Max}@f$ and @f$k_{\infty Min}@f$ are arguments of the constructor.
-
-Method 2 :
-
-Another constructor allows to perform the following:
The Pu content is set such as it has to verify
@f$ k(WantedTime) = k_{target}@f$ with @f$k_{target}@f$ is often close to 1.0
but can be set by user. The wanted time is often either
@@ -49,12 +41,17 @@ The Pu content is set such as it has to verify
@f$<k_{\infty}>^{batch}(t) = \frac{1}{N}\sum_{i}^{N}k_{\infty}(t+\frac{iT}{N} )@f$
@author BLG
+ @author BaM
@version 1.0
*/
//________________________________________________________________________
+class EQM_FBR_MLP_Keff;
+#ifndef __CINT__
+typedef void (EQM_FBR_MLP_Keff::*MLP_FBR_Keff_DMthPtr)( const string & ) ;
+#endif
-class EQM_MLP_Keff_FBR : public EquivalenceModel
+class EQM_FBR_MLP_Keff : public EquivalenceModel
{
public :
/*!
@@ -62,58 +59,31 @@ class EQM_MLP_Keff_FBR : public EquivalenceModel
*/
//@{
- //{
- /// Create a EQM_MLP_Keff_FBR using @f$k_{\infty}@f$ average over batch
- /// (see class desctiption)
- /*!
- Create a EQM_MLP_Keff_FBR using @f$k_{\infty}@f$ average over batch
- \param TMVAWeightPath0: Path to the .xml file containing neural network informations for prediction of keff(t)
- \param NumOfBatch : Number of batch for the loading plan (often 5 for FBR-Na)
- \param KeffMin : Lower average @f$<k_{\infty}>@f$ value
- \param KeffMax : Upper average @f$<k_{\infty}>@f$ value
- \param InformationFile : Total path to the file containing time steps, fissile and ferile list (ante and post fabrication time cooling). Default is the same total path as TMVAWeightPath but extension is replaced by .nfo (see manual for format)
- */
- EQM_MLP_Keff_FBR(string TMVAWeightPath, int NumOfBatch , double LowerKeffective, double UpperKeffective, string InformationFile="");
- //}
- //{
- /// Create a EQM_MLP_Keff_FBR using @f$k_{\infty}@f$ average over batch
- /// (see class desctiption)
- /*!
- Create a EQM_MLP_Keff_FBR using @f$k_{\infty}@f$ average over batch
- \param log: CLASSLogger object to handle log messages
- \param TMVAWeightPath0: Path to the .xml file containing neural network informations for prediction of keff(t)
- \param NumOfBatch : Number of batch for the loading plan (often 5 for FBR-Na)
- \param KeffMin : Lower average @f$<k_{\infty}>@f$ value
- \param KeffMax : Upper average @f$<k_{\infty}>@f$ value
- \param InformationFile : Total path to the file containing time steps, fissile and ferile list (ante and post fabrication time cooling). Default is the same total path as TMVAWeightPath but extension is replaced by .nfo (see manual for format)
- */
- EQM_MLP_Keff_FBR(CLASSLogger* log, string TMVAWeightPath, int NumOfBatch , double LowerKeffective, double UpperKeffective, string InformationFile="");
- //}
//{
- /// Create a EQM_MLP_Keff_FBR using Keffective at a given time
+ /// Create a EQM_FBR_MLP_Keff using Keffective at a given time
/// (see class desctiption)
/*!
- Create a EQM_MLP_Keff_FBR
+ Create a EQM_FBR_MLP_Keff
\param TMVAWeightPath : Path to the .xml file containing neural network informations for prediction of keff(t=tfixed)
\param keff_target : Wanted @f$k_{eff}@f$ (see detailed description)
\param InformationFile : Total path to the file containing time steps, fissile and ferile list (ante and post fabrication time cooling). Default is the same total path as TMVAWeightPath but extension is replaced by .nfo (see manual for format)
*/
- EQM_MLP_Keff_FBR(string TMVAWeightPath, double keff_target = 1.00, string InformationFile="");
+ EQM_FBR_MLP_Keff(string TMVAWeightPath, double keff_target = 1.00, string InformationFile="");
//}
//{
- /// Create a EQM_MLP_Keff_FBR using Keffective at a given time
+ /// Create a EQM_FBR_MLP_Keff using Keffective at a given time
/// (see class desctiption)
/*!
- Create a EQM_MLP_Keff_FBR
+ Create a EQM_FBR_MLP_Keff
\param log: CLASSLogger object to handle log messages
\param TMVAWeightPath : Path to the .xml file containing neural network informations for prediction of keff(t=tfixed)
\param keff_target : Wanted @f$k_{eff}@f$ (see detailed description)
\param InformationFile : Total path to the file containing time steps, fissile and ferile list (ante and post fabrication time cooling). Default is the same total path as TMVAWeightPath but extension is replaced by .nfo (see manual for format)
*/
- EQM_MLP_Keff_FBR(CLASSLogger* log, string TMVAWeightPath, double keff_target = 1.00, string InformationFile="");
+ EQM_FBR_MLP_Keff(CLASSLogger* log, string TMVAWeightPath, double keff_target = 1.00, string InformationFile="");
//}
//@}
@@ -136,38 +106,138 @@ class EQM_MLP_Keff_FBR : public EquivalenceModel
double GetPCMprecision(){return fPCMprecision/1e5;} //!< Get the precision on <k> prediction []. Neural network predictor constructors
//@}
+
+
+
+
+
+ /*!
+ \name TMVA related methods
+ */
+ //@{
TTree* CreateTMVAInputTree(IsotopicVector FreshFuel, double ThisTime);//!<Create input tmva tree to be read by ExecuteTMVA
+
double ExecuteTMVA(TTree* theTree, bool IsTimeDependant);//!<Execute the MLP according to the input tree created by CreateTMVAInputTree
+ //@}
+
+
+
+ /*!
+ \name Reading NFO related Method
+ */
+ //@{
+
+ //{
+ /// LoadKeyword() : make the correspondance between keyword and reading method
+ void LoadKeyword();
+ //}
+
+ //{
+ /// ReadTimeSteps : read the time step of the model
+ /*!
+ \param line : line suppossed to contain the time step information starts with "k_timestep" keyword
+ */
+ void ReadTimeSteps(const string &line);
+ //}
+
+ //{
+ /// ReadSpecificPower : read the Specific Power of the DataBase
+ /*!
+ \param line : line suppossed to contain the Specific Power information starts with "k_specpower" keyword
+ */
+ void ReadSpecificPower(const string &line);
+ //}
+ //{
+ /// ReadMaximalContent : read the approx. maximum fissile content reachable by the MLP model
+ /*!
+ \param line : line suppossed to contain the maximal content information starts with "k_contentmax" keyword
+ */
+ void ReadMaximalContent(const string &line);
+ //}
+
+ //{
+ /// ReadZAIName : read the zai name in the TMWA MLP model
+ /*!
+ \param line : line suppossed to contain the ZAI name starts with "k_zainame" keyword
+ */
+ void ReadZAIName(const string &line);
+ //}
+
+ //{
+ /// ReadFissil : read the zai name in the TMWA MLP model starts with "k_fissil" keyword
+ /*!
+ \param line : line suppossed to contain the fissil list
+ */
+ void ReadFissil(const string &line);
+ //}
+ //{
+ /// ReadFertil : read the zai name in the TMWA MLP model starts with "k_fertil" keyword
+ /*!
+ \param line : line suppossed to contain the fertil list & their default isotopic fraction
+ */
+ void ReadFertil(const string &line);
+ //}
+
+ //{
+ /// ReadLine : read a line
+ /*!
+ \param line : line to read
+ */
+ void ReadLine(string line);
+ //}
+
+ //@}
+
+
+
private :
- void GetModelInformation();//!<Read the fMLPInformationFile and fill containers and variables
- double GetKeffAtFixedTime(IsotopicVector FreshFuel){return ExecuteTMVA( CreateTMVAInputTree(FreshFuel,-1), false );} //!<time independant since the MLP is trained for 1 time
- TGraph* BuildKeffGraph(IsotopicVector FreshFuel);
- TGraph* BuildAverageKeffGraph(TGraph* GRAPH_KEFF);
- double GetKeffAt(TGraph* GRAPH_KEFF, int Step);
- double GetFissileContent_keffAveragePredictor(IsotopicVector Fissile, IsotopicVector Fertile);
- double GetFissileMolarFraction_keffPredictor(IsotopicVector Fissile,IsotopicVector Fertile);
+ string fTMVAWeightPath; //!<The weight needed by TMVA to construct and execute the multilayer perceptron
+ string fMLPInformationFile; //!<The path to the informations necessary to execute the MLP
+#ifndef __CINT__
+ map<string, MLP_FBR_Keff_DMthPtr> fDKeyword;
+#endif
- int fNumberOfBatch; //!< The number of batches for the loading plan
- double fKThreshold; //!< The @f$k_{Threshold}@f$
+ void GetModelInformation();//!<Read the fMLPInformationFile and fill containers and variables
+
+ map<ZAI,string> fMapOfTMVAVariableNames;//!< List of TMVA input variable names (read from fMLPInformationFile ) , name depends on the training step
+
+ vector<double> fMLP_Time; //!< Time (in seconds) when the MLP(t)=keff(t) has been trained.
double fSpecificPower; //!< The specific power in W/gHM (HM: heavy Metal)
double fMaximalContent; //!< The approx. maximum fissile content reachable by the MLP model
+
+
+
+
+
+ int fNumberOfBatch; //!< The number of batches for the loading plan
+
+ double fKThreshold; //!< The @f$k_{Threshold}@f$
double fPCMprecision; //!< precision on <k> prediction [pcm]
+
bool fIsAverageKeff; //!< True if using the first contructor (fissile content prediction with average keff (over batches))
double fKmin; //!< Lower edge of kedd Used by second constructor (fissile content prediction using keff at BOC (or other time)
double fKmax; //!< Upper edge of kedd Used by second constructor (fissile content prediction using keff at BOC (or other time)
double fTargetKeff; //!< Use for Varying Fissile content to reach fTargetKeff at time used in the MLP Training
+
- vector<double> fMLP_Time; //!< Time (in seconds) when the MLP(t)=keff(t) has been trained.
+
+
-
- map<ZAI,string> fMapOfTMVAVariableNames;//!< List of TMVA input variable names (read from fMLPInformationFile ) , name depends on the training step
+
+ double GetKeffAtFixedTime(IsotopicVector FreshFuel){return ExecuteTMVA( CreateTMVAInputTree(FreshFuel,-1), false );} //!<time independant since the MLP is trained for 1 time
- string fTMVAWeightPath; //!<The weight needed by TMVA to construct and execute the multilayer perceptron
- string fMLPInformationFile; //!<The path to the informations necessary to execute the MLP
+ TGraph* BuildKeffGraph(IsotopicVector FreshFuel);
+ TGraph* BuildAverageKeffGraph(TGraph* GRAPH_KEFF);
+
+ double GetKeffAt(TGraph* GRAPH_KEFF, int Step);
+
+
+
+
};
#endif
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff_BOUND.cxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff_BOUND.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..639dd8fb58ce4cba01d85aa98696f19e73f98f8b
--- /dev/null
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff_BOUND.cxx
@@ -0,0 +1,466 @@
+#include "EQM_FBR_MLP_Keff_BOUND.hxx"
+#include "CLASSLogger.hxx"
+#include "StringLine.hxx"
+
+#include <string>
+#include <iostream>
+#include <fstream>
+#include <algorithm>
+#include <cmath>
+#include <cassert>
+
+#include "TSystem.h"
+#include "TMVA/Reader.h"
+#include "TMVA/Tools.h"
+#include "TMVA/MethodCuts.h"
+
+//________________________________________________________________________
+//
+// EQM_FBR_MLP_Keff_BOUND
+//
+// Equivalenve Model based on multi layer perceptron from TMVA (root cern)
+// For FBR
+//
+//________________________________________________________________________
+
+
+
+//________________________________________________________________________
+//
+// Objects & Methods for content prediction with calculation of Keff bounded
+// over batches.
+//
+//________________________________________________________________________
+
+//________________________________________________________________________
+EQM_FBR_MLP_Keff_BOUND::EQM_FBR_MLP_Keff_BOUND(string TMVAWeightPath, int NumOfBatch, double LowerKeffective, double UpperKeffective, string InformationFile):EquivalenceModel(new CLASSLogger("EQM_FBR_MLP_Keff_BOUND.log"))
+{
+ fIsAverageKeff = true;
+
+ /**The tmva weight*/
+ fTMVAWeightPath = TMVAWeightPath;
+
+ /*INFORMATION FILE HANDLING*/
+ if(InformationFile=="")
+ InformationFile = StringLine::ReplaceAll(TMVAWeightPath,".xml",".nfo");
+
+ fInformationFile = InformationFile;
+
+ GetModelInformation();//Getting information from fMLPInformationFile
+
+ /*OTHER MODEL PARAMETERS*/
+ fNumberOfBatch = NumOfBatch;
+ fKmin = LowerKeffective ;
+ fKmax = UpperKeffective ;
+
+ /*MODEL PARAMETERS INITIALIZATION */
+ SetPCMprecision(10);
+ SetBuildFuelFirstGuess(0.15);//First fissile content guess for the EquivalenceModel::BuildFuel algorithm
+ fActualFissileContent = fFirstGuessFissilContent ;
+
+ INFO << "__An equivalence model has been define__"<<endl;
+ INFO << "\tThis model is based on the prediction of keff averaged over the number of batch"<<endl;
+ INFO << "\tThe TMVA (weight | information) files are :"<<endl;
+ INFO << "\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )"<<endl;
+}
+//________________________________________________________________________
+EQM_FBR_MLP_Keff_BOUND::EQM_FBR_MLP_Keff_BOUND(CLASSLogger* log, string TMVAWeightPath, int NumOfBatch, double LowerKeffective, double UpperKeffective, string InformationFile):EquivalenceModel(log)
+{
+ fIsAverageKeff = true;
+ /**The tmva weight*/
+ fTMVAWeightPath = TMVAWeightPath;
+
+ /*INFORMATION FILE HANDLING*/
+ if(InformationFile=="")
+ InformationFile = StringLine::ReplaceAll(TMVAWeightPath,".xml",".nfo");
+
+ fInformationFile = InformationFile;
+ GetModelInformation();//Getting information from fMLPInformationFile
+
+ /*OTHER MODEL PARAMETERS*/
+ fNumberOfBatch = NumOfBatch;
+ fKmin = LowerKeffective ;
+ fKmax = UpperKeffective ;
+
+ /*MODEL PARAMETERS INITIALIZATION */
+ SetPCMprecision(10);
+ SetBuildFuelFirstGuess(0.15);//First fissile content guess for the EquivalenceModel::BuildFuel algorithm
+ fActualFissileContent = fFirstGuessFissilContent ;
+
+ INFO << "__An equivalence model has been define__" << endl;
+ INFO << "\tThis model is based on the prediction of keff averaged over the number of batch" << endl;
+ INFO << "\tThe TMVA (weight | information) files are :" << endl;
+ INFO << "\t" << "( " << fTMVAWeightPath[0] << " | " << fMLPInformationFile << " )" << endl;
+}
+//________________________________________________________________________
+TGraph* EQM_FBR_MLP_Keff_BOUND::BuildKeffGraph(IsotopicVector FreshFuel)
+{
+ if(!fIsAverageKeff)
+ {
+ ERROR << " Can't be used with EQM_FBR_MLP_Keff_BOUND(string TMVAWeightPath, double keff_target, string InformationFile) constructor";
+ exit(1);
+ }
+
+ TGraph * keffGraph = new TGraph();
+ for(int i = 0 ; i < (int) fMLP_Time.size() ; i++)
+ {
+ double keff_t = ExecuteTMVA( CreateTMVAInputTree(FreshFuel,(float) fMLP_Time[i]), true );
+ keffGraph->SetPoint(i, (double)fMLP_Time[i], keff_t );
+ }
+
+ return keffGraph;
+}
+//________________________________________________________________________
+TGraph* EQM_FBR_MLP_Keff_BOUND::BuildAverageKeffGraph(TGraph* GRAPH_KEFF)
+{
+ if(!fIsAverageKeff)
+ {
+ ERROR << " Can't be used with EQM_FBR_MLP_Keff_BOUND(string TMVAWeightPath, double keff_target, string InformationFile) constructor";
+ exit(1);
+ }
+
+ TGraph * AveragekeffGraph = new TGraph();
+ int NumberOfPoint = 50;
+
+ int NumOfInputGraphPoint = GRAPH_KEFF->GetN()-1 ;
+ double TimeFinal = 0;
+ double KFinal = 0;
+
+ GRAPH_KEFF->GetPoint(NumOfInputGraphPoint, TimeFinal, KFinal);
+
+ double step = TimeFinal/NumberOfPoint;
+ int p=0;
+ for(int n = 0 ;n<NumberOfPoint;n++)
+ {
+ double k_av = 0;
+ for(int b=0;b<fNumberOfBatch;b++)
+ {
+ if((step*p)> TimeFinal/(double)fNumberOfBatch)
+ p=0;
+ k_av += GRAPH_KEFF->Eval( (step*p + b*TimeFinal/(double)fNumberOfBatch) , 0 , "S" );
+
+ }
+ p++;
+ k_av/=(double)fNumberOfBatch;
+
+ AveragekeffGraph->SetPoint(n, step*n, k_av);
+ }
+
+ return AveragekeffGraph;
+}
+//________________________________________________________________________
+double EQM_FBR_MLP_Keff_BOUND::GetKeffAt(TGraph* GRAPH_KEFF, int Step)
+{
+ if(!fIsAverageKeff)
+ {
+ ERROR << " Can't be used with EQM_FBR_MLP_Keff_BOUND(string TMVAWeightPath, double keff_target, string InformationFile) constructor"; exit(1);
+ }
+
+ double Time = 0;
+ double Keff=0;
+ GRAPH_KEFF->GetPoint(Step, Time, Keff);
+
+ return Keff;
+}
+
+
+//________________________________________________________________________
+TTree* EQM_FBR_MLP_Keff_BOUND::CreateTMVAInputTree(IsotopicVector TheFreshfuel, double ThisTime)
+{
+ /******Create Input data tree to be interpreted by TMVA::Reader***/
+ TTree* InputTree = new TTree("InTMPKef", "InTMPKef");
+
+ vector<float> InputTMVA;
+ for(int i = 0 ; i< (int)fMapOfTMVAVariableNames.size() ; i++)
+ InputTMVA.push_back(0);
+
+ float Time=0;
+
+ IsotopicVector IVInputTMVA;
+ map<ZAI ,string >::iterator it;
+ int j=0;
+
+ for( it = fMapOfTMVAVariableNames.begin() ; it!=fMapOfTMVAVariableNames.end() ; it++)
+ {
+ InputTree->Branch( ((*it).second).c_str() ,&InputTMVA[j], ((*it).second + "/F").c_str());
+ IVInputTMVA+= ((*it).first)*1;
+ j++;
+ }
+
+ if(ThisTime!=-1)
+ InputTree->Branch( "Time" ,&Time ,"Time/F" );
+
+ IsotopicVector IVAccordingToUserInfoFile = TheFreshfuel.GetThisComposition(IVInputTMVA);
+
+ double Ntot = IVAccordingToUserInfoFile.GetSumOfAll();
+
+ IVAccordingToUserInfoFile = IVAccordingToUserInfoFile/Ntot;
+
+ j=0;
+ map<ZAI ,string >::iterator it2;
+
+ for( it2 = fMapOfTMVAVariableNames.begin() ; it2!=fMapOfTMVAVariableNames.end() ; it2++)
+ {
+ InputTMVA[j] = IVAccordingToUserInfoFile.GetZAIIsotopicQuantity( (*it2).first ) ;
+ j++;
+ }
+
+ Time=ThisTime;
+
+ InputTree->Fill();
+
+ return InputTree;
+
+}
+//________________________________________________________________________
+double EQM_FBR_MLP_Keff_BOUND::ExecuteTMVA(TTree* InputTree, bool IsTimeDependent)
+{
+
+ // --- Create the Reader object
+ TMVA::Reader *reader = new TMVA::Reader( "Silent" );
+
+ // Create a set of variables and declare them to the reader
+ // - the variable names MUST corresponds in name and type to those given in the weight file(s) used
+ vector<float> InputTMVA;
+ for(int i = 0 ; i< (int)fMapOfTMVAVariableNames.size() ; i++)
+ InputTMVA.push_back(0);
+ Float_t Time;
+
+ map<ZAI ,string >::iterator it;
+ int j=0;
+ for( it = fMapOfTMVAVariableNames.begin() ; it!=fMapOfTMVAVariableNames.end() ; it++)
+ { reader->AddVariable( ( (*it).second ).c_str(),&InputTMVA[j]);
+ j++;
+ }
+
+ if(IsTimeDependent)
+ reader->AddVariable( "Time" ,&Time);
+
+ // --- Book the MVA methods
+
+ // Book method MLP
+ TString methodName = "MLP method";
+ reader->BookMVA( methodName, fTMVAWeightPath );
+
+ map<ZAI ,string >::iterator it2;
+ j=0;
+ for( it2 = fMapOfTMVAVariableNames.begin() ; it2!=fMapOfTMVAVariableNames.end() ; it2++)
+ {
+ InputTree->SetBranchAddress(( (*it2).second ).c_str(),&InputTMVA[j]);
+ j++;
+ }
+
+ if(IsTimeDependent)
+ InputTree->SetBranchAddress( "Time" ,&Time );
+
+ InputTree->GetEntry(0);
+ Float_t val = (reader->EvaluateRegression( methodName ))[0];
+
+ delete reader;
+
+ return (double)val; //return k_{eff}(t=Time)
+}
+
+//________________________________________________________________________
+void XSM_MLP::LoadKeyword()
+{
+ DBGL
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_timestep", & EQM_FBR_MLP_Keff_BOUND::ReadTimeSteps));
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_specpower", & EQM_FBR_MLP_Keff_BOUND::ReadSpecificPower));
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_contentmax", & EQM_FBR_MLP_Keff_BOUND::ReadMaximalContent));
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_zainame", & EQM_FBR_MLP_Keff_BOUND::ReadZAIName) );
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_fissil", & EQM_FBR_MLP_Keff_BOUND::ReadFissil) );
+ fDKeyword.insert( pair<string, MLP_FBR_Keff_DMthPtr>( "k_fertil", & EQM_FBR_MLP_Keff_BOUND::ReadFertil) );
+ DBGL
+}
+
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff_BOUND::ReadZAIName(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_zainame" ) // Check the keyword
+ {
+ ERROR << " Bad keyword : \"k_zainame\" not found !" << endl;
+ exit(1);
+ }
+
+ int Z = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int A = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int I = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+
+ fFissileList.Add(Z, A, I, 1.0);
+
+ DBGL
+}
+
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff_BOUND::ReadSpecificPower(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_specpower") // Check the keyword
+ {
+ ERROR << " Bad keyword : \â€k_specpower\" Not found !" << endl;
+ exit(1);
+ }
+
+ fSpecificPower = atof(StringLine::NextWord(line, pos, ' '));
+
+ DBGL
+}
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff_BOUND::ReadMaximalContent(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_contentmax") // Check the keyword
+ {
+ ERROR << " Bad keyword : \â€k_contentmax\" Not found !" << endl;
+ exit(1);
+ }
+
+ fMaximalContent = atof(StringLine::NextWord(line, pos, ' '));
+
+ DBGL
+}
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff_BOUND::ReadFissil(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_fissil" ) // Check the keyword
+ {
+ ERROR << " Bad keyword : \"k_fissil\" not found !" << endl;
+ exit(1);
+ }
+
+ int Z = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int A = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int I = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ double Q = atof(StringLine::NextWord(line, pos, ' ').c_str());
+
+ fFertileList.Add(Z, A, I, Q);
+
+ DBGL
+}
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff_BOUND::ReadFertil(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_fertil" ) // Check the keyword
+ {
+ ERROR << " Bad keyword : \"k_fertil\" not found !" << endl;
+ exit(1);
+ }
+
+ int Z = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int A = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+ int I = atoi(StringLine::NextWord(line, pos, ' ').c_str());
+
+ string name = StringLine::NextWord(line, pos, ' ');
+
+ fMapOfTMVAVariableNames.insert( pair<ZAI,string>( ZAI(Z, A, I), name ) );
+
+ DBGL
+}
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff_BOUND::ReadTimeSteps(const string &line)
+{
+ DBGL
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+ if( keyword != "k_timestep" ) // Check the keyword
+ {
+ ERROR << " Bad keyword : \"k_timestep\" not found !" << endl;
+ exit(1);
+ }
+
+ while( pos < (int)line.size() )
+ fMLP_Time.push_back( atof( (StringLine::NextWord(line,pos,' ')).c_str() ));
+ DBGL
+}
+
+
+//________________________________________________________________________
+void EQM_FBR_MLP_Keff_BOUND::ReadLine(string line)
+{
+ DBGL
+
+ int pos = 0;
+ string keyword = tlc(StringLine::NextWord(line, pos, ' '));
+
+ map<string, XS_MLP_DMthPtr>::iterator it = fDKeyword.find(keyword);
+
+ if(it != fDKeyword.end())
+ (this->*(it->second))( line );
+
+ DBGL
+}
+
+
+//________________________________________________________________________
+double EQM_FBR_MLP_Keff_BOUND::GetFissileMolarFraction(IsotopicVector Fissile, IsotopicVector Fertile, double TargetBU)
+{
+ if(TargetBU != 0)
+ WARNING<<"The third arguement : Burnup has no effect here.";
+
+ /**Algorithm not so clever ...**/
+ /**need improvements to make it faster*/
+
+ if(!fIsAverageKeff)
+ {
+ ERROR << " Can't be used with EQM_FBR_MLP_Keff_BOUND(string TMVAWeightPath, double keff_target, string InformationFile) constructor";
+ exit(1);
+ }
+
+ double FissileContent = 0.01;
+ double test_Keff_beg = fKmin - 0.01;
+ double test_keff_end = fKmax + 0.01;
+
+ double speedstep = 1;
+
+ while(fKmin >= test_Keff_beg || fKmax <= test_keff_end)
+ {
+ IsotopicVector FreshFuel = (1-FissileContent)*(Fertile/Fertile.GetSumOfAll()) + FissileContent*(Fissile/Fissile.GetSumOfAll());
+
+ TGraph* KEFF = BuildKeffGraph(FreshFuel);
+ TGraph* KEFF_avg = BuildAverageKeffGraph(KEFF);
+
+ test_Keff_beg = GetKeffAt(KEFF_avg , 0);
+ test_keff_end = GetKeffAt(KEFF_avg , fMLP_Time.size()-1);
+ delete KEFF;
+ delete KEFF_avg;
+
+ if(test_Keff_beg < 0.9) //why 0.9 ? exactly
+ speedstep = 10;
+ else
+ speedstep = 1;
+
+ FissileContent+=0.001*speedstep;
+
+ if( test_Keff_beg > 1.30 )
+ {
+ cout << "This plutonium can not satisfy the criticality condition imposed" << endl;
+ FissileContent = -1;
+ break;
+ }
+
+ }
+
+ return FissileContent;
+
+}
+//________________________________________________________________________
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff_BOUND.hxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff_BOUND.hxx
new file mode 100644
index 0000000000000000000000000000000000000000..11ad0078d929bf63a5bb8df50a10cd8cdd08ab39
--- /dev/null
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_FBR_MLP_Keff_BOUND.hxx
@@ -0,0 +1,266 @@
+#ifndef _EQM_FBR_MLP_Keff_BOUND_HXX
+#define _EQM_FBR_MLP_Keff_BOUND_HXX
+
+#include "EquivalenceModel.hxx"
+#include "TTree.h"
+#include "TGraph.h"
+
+/*!
+ \file
+ \brief Header file for EQM_FBR_MLP_Keff_BOUND class.
+
+
+ @author BLG
+ @author BaM
+ @version 1.0
+ */
+
+
+using namespace std;
+
+//-----------------------------------------------------------------------------//
+//! Defines an EquivalenceModel based on neural network to predict @f$k_{eff}@f$
+/*!
+ The aim of these class is to constuct a fuel from an equivalence model
+ based on a Multi layer perceptron (MLP).
+ This MLP aims to predict :
+
+ The @f$k_{\infty}(t)@f$ of a FBR-MOX from a given fresh fuel composition.
+ With this MLP prediction and a given number of batch (for the loading plan) an
+ average @f$<k_{\infty}(t)>@f$ is calculated according :
+ @f$<k_{\infty}>^{batch}(t) = \frac{1}{N}\sum_{i}^{N} k_{\infty}(t + \frac{iT}{N} )@f$
+ The Fissile content has to verify this condition :
+ @f$ k_{\infty Max} \geq <k_{\infty}>^{batch}(T/N) \geq k_{\infty Min} @f$
+ Where @f$ k_{\infty Max}@f$ and @f$k_{\infty Min}@f$ are arguments of the constructor.
+
+
+ \warning
+ it is not guaranted that there is a solution for Pu content verifying :
+ @f$<k_{\infty}>^{batch}(t) = \frac{1}{N}\sum_{i}^{N}k_{\infty}(t+\frac{iT}{N} )@f$
+
+ @author BLG
+ @author BaM
+ @version 1.0
+ */
+//________________________________________________________________________
+
+class EQM_FBR_MLP_Keff_BOUND;
+#ifndef __CINT__
+typedef void (EQM_FBR_MLP_Keff_BOUND::*MLP_FBR_Keff_DMthPtr)( const string & ) ;
+#endif
+
+
+class EQM_FBR_MLP_Keff_BOUND : public EquivalenceModel
+{
+ public :
+ /*!
+ \name Constructor
+ */
+ //@{
+
+ //{
+ /// Create a EQM_FBR_MLP_Keff_BOUND using @f$k_{\infty}@f$ average over batch
+ /// (see class desctiption)
+ /*!
+ Create a EQM_FBR_MLP_Keff_BOUND using @f$k_{\infty}@f$ average over batch
+ \param TMVAWeightPath0: Path to the .xml file containing neural network informations for prediction of keff(t)
+ \param NumOfBatch : Number of batch for the loading plan (often 5 for FBR-Na)
+ \param KeffMin : Lower average @f$<k_{\infty}>@f$ value
+ \param KeffMax : Upper average @f$<k_{\infty}>@f$ value
+ \param InformationFile : Total path to the file containing time steps, fissile and ferile list (ante and post fabrication time cooling). Default is the same total path as TMVAWeightPath but extension is replaced by .nfo (see manual for format)
+ */
+ EQM_FBR_MLP_Keff_BOUND(string TMVAWeightPath, int NumOfBatch , double LowerKeffective, double UpperKeffective, string InformationFile="");
+ //}
+
+ //{
+ /// Create a EQM_FBR_MLP_Keff_BOUND using @f$k_{\infty}@f$ average over batch
+ /// (see class desctiption)
+ /*!
+ Create a EQM_FBR_MLP_Keff_BOUND using @f$k_{\infty}@f$ average over batch
+ \param log: CLASSLogger object to handle log messages
+ \param TMVAWeightPath0: Path to the .xml file containing neural network informations for prediction of keff(t)
+ \param NumOfBatch : Number of batch for the loading plan (often 5 for FBR-Na)
+ \param KeffMin : Lower average @f$<k_{\infty}>@f$ value
+ \param KeffMax : Upper average @f$<k_{\infty}>@f$ value
+ \param InformationFile : Total path to the file containing time steps, fissile and ferile list (ante and post fabrication time cooling). Default is the same total path as TMVAWeightPath but extension is replaced by .nfo (see manual for format)
+ */
+ EQM_FBR_MLP_Keff_BOUND(CLASSLogger* log, string TMVAWeightPath, int NumOfBatch , double LowerKeffective, double UpperKeffective, string InformationFile="");
+ //}
+
+
+ //@}
+
+ //{
+ /// Return the molar fissile fraction according fissile & ferile content using @f$<k_{\infty}>(t)@f$ prediction
+ /*!
+ \param Fissil : The composition of the fissile matter
+ \param Fertil : The composition of the Fertil matter
+ \param BurnUp : Maximum achievable burn up envisaged
+ */
+ virtual double GetFissileMolarFraction(IsotopicVector Fissil,IsotopicVector Fertil,double BurnUp=0);
+ //}
+
+ /*!
+ \name Get/Set methods
+ */
+ //@{
+ void SetPCMprecision(double pcm){fPCMprecision = pcm;} //!< Set the precision on <k> prediction [pcm]. Neural network predictor constructors
+ double GetPCMprecision(){return fPCMprecision/1e5;} //!< Get the precision on <k> prediction []. Neural network predictor constructors
+
+ //@}
+
+
+
+
+
+ /*!
+ \name TMVA related methods
+ */
+ //@{
+ TTree* CreateTMVAInputTree(IsotopicVector FreshFuel, double ThisTime);//!<Create input tmva tree to be read by ExecuteTMVA
+
+ double ExecuteTMVA(TTree* theTree, bool IsTimeDependant);//!<Execute the MLP according to the input tree created by CreateTMVAInputTree
+ //@}
+
+
+
+ /*!
+ \name Reading NFO related Method
+ */
+ //@{
+
+ //{
+ /// LoadKeyword() : make the correspondance between keyword and reading method
+ void LoadKeyword();
+ //}
+
+ //{
+ /// ReadTimeSteps : read the time step of the model
+ /*!
+ \param line : line suppossed to contain the time step information starts with "k_timestep" keyword
+ */
+ void ReadTimeSteps(const string &line);
+ //}
+
+ //{
+ /// ReadSpecificPower : read the Specific Power of the DataBase
+ /*!
+ \param line : line suppossed to contain the Specific Power information starts with "k_specpower" keyword
+ */
+ void ReadSpecificPower(const string &line);
+ //}
+
+ //{
+ /// ReadMaximalContent : read the approx. maximum fissile content reachable by the MLP model
+ /*!
+ \param line : line suppossed to contain the maximal content information starts with "k_contentmax" keyword
+ */
+ void ReadMaximalContent(const string &line);
+ //}
+
+ //{
+ /// ReadZAIName : read the zai name in the TMWA MLP model
+ /*!
+ \param line : line suppossed to contain the ZAI name starts with "k_zainame" keyword
+ */
+ void ReadZAIName(const string &line);
+ //}
+
+ //{
+ /// ReadFissil : read the zai name in the TMWA MLP model starts with "k_fissil" keyword
+ /*!
+ \param line : line suppossed to contain the fissil list
+ */
+ void ReadFissil(const string &line);
+ //}
+
+ //{
+ /// ReadFertil : read the zai name in the TMWA MLP model starts with "k_fertil" keyword
+ /*!
+ \param line : line suppossed to contain the fertil list & their default isotopic fraction
+ */
+ void ReadFertil(const string &line);
+ //}
+
+ //{
+ /// ReadLine : read a line
+ /*!
+ \param line : line to read
+ */
+ void ReadLine(string line);
+ //}
+
+ //@}
+
+
+
+ private :
+
+ string fTMVAWeightPath; //!<The weight needed by TMVA to construct and execute the multilayer perceptron
+ string fMLPInformationFile; //!<The path to the informations necessary to execute the MLP
+
+#ifndef __CINT__
+ map<string, MLP_FBR_Keff_DMthPtr> fDKeyword;
+#endif
+
+ void GetModelInformation();//!<Read the fMLPInformationFile and fill containers and variables
+
+ map<ZAI,string> fMapOfTMVAVariableNames;//!< List of TMVA input variable names (read from fMLPInformationFile ) , name depends on the training step
+
+ vector<double> fMLP_Time; //!< Time (in seconds) when the MLP(t)=keff(t) has been trained.
+ double fSpecificPower; //!< The specific power in W/gHM (HM: heavy Metal)
+ double fMaximalContent; //!< The approx. maximum fissile content reachable by the MLP model
+
+
+
+
+
+ int fNumberOfBatch; //!< The number of batches for the loading plan
+
+ double fKThreshold; //!< The @f$k_{Threshold}@f$
+ double fPCMprecision; //!< precision on <k> prediction [pcm]
+
+ bool fIsAverageKeff; //!< True if using the first contructor (fissile content prediction with average keff (over batches))
+ double fKmin; //!< Lower edge of kedd Used by second constructor (fissile content prediction using keff at BOC (or other time)
+ double fKmax; //!< Upper edge of kedd Used by second constructor (fissile content prediction using keff at BOC (or other time)
+ double fTargetKeff; //!< Use for Varying Fissile content to reach fTargetKeff at time used in the MLP Training
+
+
+
+
+
+
+ double GetKeffAtFixedTime(IsotopicVector FreshFuel){return ExecuteTMVA( CreateTMVAInputTree(FreshFuel,-1), false );} //!<time independant since the MLP is trained for 1 time
+
+ TGraph* BuildKeffGraph(IsotopicVector FreshFuel);
+ TGraph* BuildAverageKeffGraph(TGraph* GRAPH_KEFF);
+
+ double GetKeffAt(TGraph* GRAPH_KEFF, int Step);
+
+
+
+
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+#endif /* defined(__CLASSSource__EQM_FBR_MLP_Keff_BOUND_BOUND__) */
+
+
+
+
+
+
+
+
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Keff_FBR.cxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Keff_FBR.cxx
deleted file mode 100644
index 0fd523c9cd5cb35d96f95f5b7705f4bef07ab9f1..0000000000000000000000000000000000000000
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Keff_FBR.cxx
+++ /dev/null
@@ -1,577 +0,0 @@
-#include "EquivalenceModel.hxx"
-#include "EQM_MLP_Keff_FBR.hxx"
-#include "CLASSLogger.hxx"
-#include "StringLine.hxx"
-
-#include <string>
-#include <iostream>
-#include <fstream>
-#include <algorithm>
-#include <cmath>
-#include <cassert>
-
-#include "TSystem.h"
-#include "TMVA/Reader.h"
-#include "TMVA/Tools.h"
-#include "TMVA/MethodCuts.h"
-
-//________________________________________________________________________
-//
-// EQM_MLP_Keff_FBR
-//
-// Equivalenve Model based on multi layer perceptron from TMVA (root cern)
-// For FBR
-//
-//________________________________________________________________________
-
-
-
-//________________________________________________________________________
-//
-// Objects & Methods for content prediction with calculation of Keff averaged
-// over batches.
-//
-//________________________________________________________________________
-
-//________________________________________________________________________
-EQM_MLP_Keff_FBR::EQM_MLP_Keff_FBR(string TMVAWeightPath, int NumOfBatch, double LowerKeffective, double UpperKeffective, string InformationFile):EquivalenceModel(new CLASSLogger("EQM_MLP_Keff_FBR.log"))
-{
- fIsAverageKeff = true;
-
- /**The tmva weight*/
- fTMVAWeightPath = TMVAWeightPath;
-
- /*INFORMATION FILE HANDLING*/
- if(InformationFile=="")
- InformationFile = StringLine::ReplaceAll(TMVAWeightPath,".xml",".nfo");
-
- fMLPInformationFile = InformationFile;
-
- GetModelInformation();//Getting information from fMLPInformationFile
-
- /*OTHER MODEL PARAMETERS*/
- fNumberOfBatch = NumOfBatch;
- fKmin = LowerKeffective ;
- fKmax = UpperKeffective ;
-
- /*MODEL PARAMETERS INITIALIZATION */
- SetPCMprecision(10);
- SetBuildFuelFirstGuess(0.15);//First fissile content guess for the EquivalenceModel::BuildFuel algorithm
- fActualFissileContent = fFirstGuessFissilContent ;
-
- INFO<<"__An equivalence model has been define__"<<endl;
- INFO<<"\tThis model is based on the prediction of keff averaged over the number of batch"<<endl;
- INFO<<"\tThe TMVA (weight | information) files are :"<<endl;
- INFO<<"\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )"<<endl;
-}
-//________________________________________________________________________
-EQM_MLP_Keff_FBR::EQM_MLP_Keff_FBR(CLASSLogger* log, string TMVAWeightPath, int NumOfBatch, double LowerKeffective, double UpperKeffective, string InformationFile):EquivalenceModel(log)
-{
- fIsAverageKeff = true;
- /**The tmva weight*/
- fTMVAWeightPath = TMVAWeightPath;
-
- /*INFORMATION FILE HANDLING*/
- if(InformationFile=="")
- InformationFile = StringLine::ReplaceAll(TMVAWeightPath,".xml",".nfo");
-
- fMLPInformationFile = InformationFile;
- GetModelInformation();//Getting information from fMLPInformationFile
-
- /*OTHER MODEL PARAMETERS*/
- fNumberOfBatch = NumOfBatch;
- fKmin = LowerKeffective ;
- fKmax = UpperKeffective ;
-
- /*MODEL PARAMETERS INITIALIZATION */
- SetPCMprecision(10);
- SetBuildFuelFirstGuess(0.15);//First fissile content guess for the EquivalenceModel::BuildFuel algorithm
- fActualFissileContent = fFirstGuessFissilContent ;
-
- INFO<<"__An equivalence model has been define__"<<endl;
- INFO<<"\tThis model is based on the prediction of keff averaged over the number of batch"<<endl;
- INFO<<"\tThe TMVA (weight | information) files are :"<<endl;
- INFO<<"\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )"<<endl;
-}
-//________________________________________________________________________
-TGraph* EQM_MLP_Keff_FBR::BuildKeffGraph(IsotopicVector FreshFuel)
-{
- if(!fIsAverageKeff)
- {ERROR<<" Can't be used with EQM_MLP_Keff_FBR(string TMVAWeightPath, double keff_target, string InformationFile) constructor";exit(1);}
-
- TGraph * keffGraph = new TGraph();
- for(int i = 0 ; i < (int) fMLP_Time.size() ; i++)
- {
- double keff_t = ExecuteTMVA( CreateTMVAInputTree(FreshFuel,(float) fMLP_Time[i]), true );
- keffGraph->SetPoint(i, (double)fMLP_Time[i], keff_t );
- }
-
- return keffGraph;
-}
-//________________________________________________________________________
-TGraph* EQM_MLP_Keff_FBR::BuildAverageKeffGraph(TGraph* GRAPH_KEFF)
-{
- if(!fIsAverageKeff)
- {ERROR<<" Can't be used with EQM_MLP_Keff_FBR(string TMVAWeightPath, double keff_target, string InformationFile) constructor";exit(1);}
-
- TGraph * AveragekeffGraph = new TGraph();
- int NumberOfPoint = 50;
-
- int NumOfInputGraphPoint = GRAPH_KEFF->GetN()-1 ;
- double TimeFinal = 0;
- double KFinal = 0;
-
- GRAPH_KEFF->GetPoint(NumOfInputGraphPoint, TimeFinal, KFinal);
-
- double step = TimeFinal/NumberOfPoint;
- int p=0;
- for(int n = 0 ;n<NumberOfPoint;n++)
- {
- double k_av = 0;
- for(int b=0;b<fNumberOfBatch;b++)
- {
- if((step*p)> TimeFinal/(double)fNumberOfBatch)
- p=0;
- k_av += GRAPH_KEFF->Eval( (step*p + b*TimeFinal/(double)fNumberOfBatch) , 0 , "S" );
-
- }
- p++;
- k_av/=(double)fNumberOfBatch;
-
- //cout<< step*n<<" "<<k_av<<endl;
- AveragekeffGraph->SetPoint(n, step*n, k_av);
- }
-
- return AveragekeffGraph;
-}
-//________________________________________________________________________
-double EQM_MLP_Keff_FBR::GetKeffAt(TGraph* GRAPH_KEFF, int Step)
-{
- if(!fIsAverageKeff)
- {ERROR<<" Can't be used with EQM_MLP_Keff_FBR(string TMVAWeightPath, double keff_target, string InformationFile) constructor";exit(1);}
-
- double Time = 0;
- double Keff=0;
- GRAPH_KEFF->GetPoint(Step, Time, Keff);
-
- return Keff;
-}
-//________________________________________________________________________
-double EQM_MLP_Keff_FBR::GetFissileContent_keffAveragePredictor(IsotopicVector Fissile, IsotopicVector Fertile)
-{
- /**Algorithm not so clever ...**/
- /**need improvements to make it faster*/
-
- if(!fIsAverageKeff)
- {ERROR<<" Can't be used with EQM_MLP_Keff_FBR(string TMVAWeightPath, double keff_target, string InformationFile) constructor";exit(1);}
-
- double FissileContent = 0.01;
- double test_Keff_beg = fKmin - 0.01;
- double test_keff_end = fKmax + 0.01;
-
- double speedstep = 1;
-
- while(fKmin >= test_Keff_beg || fKmax <= test_keff_end)
- {
- IsotopicVector FreshFuel = (1-FissileContent)*(Fertile/Fertile.GetSumOfAll()) + FissileContent*(Fissile/Fissile.GetSumOfAll());
-
- TGraph* KEFF = BuildKeffGraph(FreshFuel);
- TGraph* KEFF_avg = BuildAverageKeffGraph(KEFF);
-
- test_Keff_beg = GetKeffAt(KEFF_avg , 0);
- test_keff_end = GetKeffAt(KEFF_avg , fMLP_Time.size()-1);
- delete KEFF;
- delete KEFF_avg;
-
- if(test_Keff_beg < 0.9) //why 0.9 ? exactly
- speedstep = 10;
- else
- speedstep = 1;
-
- FissileContent+=0.001*speedstep;
-
- if( test_Keff_beg > 1.30 )
- {
- cout<<"This plutonium can not satisfy the criticality condition imposed"<<endl;
- FissileContent = -1;
- break;
- }
-
- }
-
- return FissileContent;
-}
-
-//________________________________________________________________________
-//
-// Objects & Methods for content prediction with calculation of Keff at
-// one given time (often BOC or EOC)
-//
-//________________________________________________________________________
-
-//________________________________________________________________________
-EQM_MLP_Keff_FBR::EQM_MLP_Keff_FBR(string TMVAWeightPath, double keff_target, string InformationFile):EquivalenceModel(new CLASSLogger("EQM_MLP_Keff_FBR.log"))
-{
- fIsAverageKeff = false;
-
- /**The tmva weight*/
- fTMVAWeightPath = TMVAWeightPath;
-
- fTargetKeff = keff_target;
-
- if(InformationFile=="")
- InformationFile = StringLine::ReplaceAll(TMVAWeightPath,".xml",".nfo");
-
- fMLPInformationFile = InformationFile;
- GetModelInformation();//Getting information from fMLPInformationFile
-
- SetPCMprecision(10);
- SetBuildFuelFirstGuess(0.15);//First fissile content guess for the EquivalenceModel::BuildFuel algorithm
- fActualFissileContent = fFirstGuessFissilContent ;
-
- INFO<<"__An equivalence model has been define__"<<endl;
- INFO<<"\tThis model is based on the prediction of keff at a specific time"<<endl;
- INFO<<"\tThe TMVA (weight | information) files are :"<<endl;
- INFO<<"\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )"<<endl;
-
-}
-//________________________________________________________________________
-EQM_MLP_Keff_FBR::EQM_MLP_Keff_FBR(CLASSLogger* log, string TMVAWeightPath, double keff_target, string InformationFile):EquivalenceModel(log)
-{
- fIsAverageKeff = false;
-
- /**The tmva weight*/
- fTMVAWeightPath = TMVAWeightPath;
-
- fTargetKeff = keff_target;
-
- if(InformationFile=="")
- InformationFile = StringLine::ReplaceAll(TMVAWeightPath,".xml",".nfo");
-
- fMLPInformationFile = InformationFile;
- GetModelInformation();//Getting information from fMLPInformationFile
-
- SetPCMprecision(10);
- SetBuildFuelFirstGuess(0.15);//First fissile content guess for the EquivalenceModel::BuildFuel algorithm
- fActualFissileContent = fFirstGuessFissilContent ;
-
- INFO<<"__An equivalence model has been define__"<<endl;
- INFO<<"\tThis model is based on the prediction of keff at a specific time"<<endl;
- INFO<<"\tThe TMVA (weight | information) files are :"<<endl;
- INFO<<"\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )"<<endl;
-
-}
-//________________________________________________________________________
-double EQM_MLP_Keff_FBR::GetFissileMolarFraction_keffPredictor(IsotopicVector Fissile,IsotopicVector Fertile)
-{
- if(fIsAverageKeff)
- {ERROR<<" Can't be used with EQM_MLP_Keff_FBR(string TMVAWeightPath, int NumOfBatch, double LowerKeffective, double UpperKeffective, string InformationFile) constructor";exit(1);}
-
- //initialization
- double FissileContent = GetActualFissileContent();
- double OldFissileContentMinus = 0;
- double OldFissileContentPlus = fMaximalContent;
- double PredictedKeff = 0 ;
- IsotopicVector FreshFuel = (1-FissileContent)*(Fertile/Fertile.GetSumOfAll()) + FissileContent*(Fissile/Fissile.GetSumOfAll());
- double OldPredictedKeff = GetKeffAtFixedTime(FreshFuel);
-
- double Precision = fPCMprecision/1e5*fTargetKeff; //pcm to 1
-
- int count = 0;
- int MaximumLoopCount = 100;
- do
- {
- if(count > MaximumLoopCount )
- {
- ERROR<<"CRITICAL ! Can't manage to predict fissile content\nHint : Try to decrease the precision on keff using :\nYourEQM_MLP_Keff_FBR->SetPCMPrecision(prop); with prop the precision (default 0.5percent : 0.005) INCREASE IT\nIf this message still appear mail to leniau@subatech.in2p3.fr\nor nicolas.thiolliere@subatech.in2p3.fr "<<endl;
- exit(1);
- }
-
- if( (OldPredictedKeff - fTargetKeff) < 0 ) //The Content can be increased
- {
- OldFissileContentMinus = FissileContent;
- FissileContent = FissileContent + fabs(OldFissileContentPlus-FissileContent)/2.;
- }
- else if( (OldPredictedKeff - fTargetKeff) > 0) //The Content is too high
- {
- OldFissileContentPlus = FissileContent;
- FissileContent = FissileContent - fabs(OldFissileContentMinus-FissileContent)/2.;
- }
-
- IsotopicVector FreshFuel = (1-FissileContent)*(Fertile/Fertile.GetSumOfAll()) + FissileContent*(Fissile/Fissile.GetSumOfAll());
- // FreshFuel.Print();
- PredictedKeff = GetKeffAtFixedTime(FreshFuel);
- // cout<<PredictedKeff<<" "<<FissileContent<<endl;;
-
- OldPredictedKeff = PredictedKeff;
- count ++;
-
- }while(fabs(fTargetKeff-PredictedKeff)>Precision);
-
- //cout<<"Predicted keff "<<PredictedKeff<<" FissileContent "<<FissileContent<<endl;;
-return FissileContent;
-}
-
-//________________________________________________________________________
-//
-// COMMON METHODS
-//
-//
-//________________________________________________________________________
-
-//________________________________________________________________________
-TTree* EQM_MLP_Keff_FBR::CreateTMVAInputTree(IsotopicVector TheFreshfuel, double ThisTime)
-{
- /******Create Input data tree to be interpreted by TMVA::Reader***/
- TTree* InputTree = new TTree("InTMPKef", "InTMPKef");
-
- vector<float> InputTMVA;
- for(int i = 0 ; i< (int)fMapOfTMVAVariableNames.size() ; i++)
- InputTMVA.push_back(0);
-
- float Time=0;
-
- IsotopicVector IVInputTMVA;
- map<ZAI ,string >::iterator it;
- int j=0;
-
- for( it = fMapOfTMVAVariableNames.begin() ; it!=fMapOfTMVAVariableNames.end() ; it++)
- {
- InputTree->Branch( ((*it).second).c_str() ,&InputTMVA[j], ((*it).second + "/F").c_str());
- IVInputTMVA+= ((*it).first)*1;
- j++;
- }
-
- if(ThisTime!=-1)
- InputTree->Branch( "Time" ,&Time ,"Time/F" );
-
- IsotopicVector IVAccordingToUserInfoFile = TheFreshfuel.GetThisComposition(IVInputTMVA);
-
- double Ntot = IVAccordingToUserInfoFile.GetSumOfAll();
-
- IVAccordingToUserInfoFile = IVAccordingToUserInfoFile/Ntot;
-
- j=0;
- map<ZAI ,string >::iterator it2;
-
- for( it2 = fMapOfTMVAVariableNames.begin() ; it2!=fMapOfTMVAVariableNames.end() ; it2++)
- {
- InputTMVA[j] = IVAccordingToUserInfoFile.GetZAIIsotopicQuantity( (*it2).first ) ;
- //DBGV((*it2).first.Z()<<" "<<(*it2).first.A()<<" "<<InputTMVA[j]);
- j++;
- }
-
- Time=ThisTime;
-
- InputTree->Fill();
-
- return InputTree;
-
-}
-//________________________________________________________________________
-double EQM_MLP_Keff_FBR::ExecuteTMVA(TTree* InputTree, bool IsTimeDependent)
-{
-
- // --- Create the Reader object
- TMVA::Reader *reader = new TMVA::Reader( "Silent" );
-
- // Create a set of variables and declare them to the reader
- // - the variable names MUST corresponds in name and type to those given in the weight file(s) used
- vector<float> InputTMVA;
- for(int i = 0 ; i< (int)fMapOfTMVAVariableNames.size() ; i++)
- InputTMVA.push_back(0);
- Float_t Time;
-
- map<ZAI ,string >::iterator it;
- int j=0;
- for( it = fMapOfTMVAVariableNames.begin() ; it!=fMapOfTMVAVariableNames.end() ; it++)
- { reader->AddVariable( ( (*it).second ).c_str(),&InputTMVA[j]);
- j++;
- }
-
- if(IsTimeDependent)
- reader->AddVariable( "Time" ,&Time);
-
- // --- Book the MVA methods
-
- // Book method MLP
- TString methodName = "MLP method";
- reader->BookMVA( methodName, fTMVAWeightPath );
-
- map<ZAI ,string >::iterator it2;
- j=0;
- for( it2 = fMapOfTMVAVariableNames.begin() ; it2!=fMapOfTMVAVariableNames.end() ; it2++)
- {
- InputTree->SetBranchAddress(( (*it2).second ).c_str(),&InputTMVA[j]);
- j++;
- }
-
- if(IsTimeDependent)
- InputTree->SetBranchAddress( "Time" ,&Time );
-
- InputTree->GetEntry(0);
- Float_t val = (reader->EvaluateRegression( methodName ))[0];
-
- delete reader;
-
- return (double)val;//return k_{eff}(t=Time)
-}
-//________________________________________________________________________
-void EQM_MLP_Keff_FBR::GetModelInformation()
-{
-DBGL
- ifstream FILE(fMLPInformationFile.c_str());
- if(FILE.good())
- {
- while(!FILE.eof())
- {
- string line;
- getline(FILE, line);
- if(line=="") //ie if eof
- break;
-
- size_t foundSpecPow = line.find("Specific Power (W/gHM) :");
- size_t foundContent = line.find("Maximal fissile content (molar proportion) :");
- size_t foundTime = line.find("Time (s) :");
- size_t foundZAI = line.find("Z A I Name (input MLP) :");
- size_t foundFissile = line.find("Fissile Liste (Z A I) :");
- size_t foundFertile = line.find("Fertile Liste (Z A I Default Proportion) :");
-
- int pos=0;
- if(foundSpecPow !=std::string::npos)
- { StringLine::NextWord(line,pos,':');
- fSpecificPower = atof( (StringLine::NextWord(line,pos,':') ).c_str() );
- }
- pos=0;
- if(foundContent!=std::string::npos)
- {
- StringLine::NextWord(line,pos,':');
- fMaximalContent = atof( (StringLine::NextWord(line,pos,':') ).c_str() );
- }
- pos=0;
- if(foundTime!=std::string::npos)
- {
- StringLine::NextWord(line,pos,':');
- while( pos< (int)line.size() )
- fMLP_Time.push_back( atof( (StringLine::NextWord(line,pos,' ')).c_str() ));
- }
- pos=0;
- if(foundZAI != std::string::npos)
- { string Z;
- string A;
- string I;
- string Name;
- int posoflinebeforbadline=0;
- do
- { posoflinebeforbadline = FILE.tellg();
- getline(FILE, line);
-
- stringstream ssline;
- ssline<<line;
- ssline>>Z>>A>>I>>Name;
- if(StringLine::IsDouble(Z) && StringLine::IsDouble(A) && StringLine::IsDouble(I) )
- {
- fMapOfTMVAVariableNames.insert( pair<ZAI,string>(ZAI(atoi(Z.c_str()),atoi(A.c_str()),atoi(I.c_str())),Name) );
- }
-
- }while((StringLine::IsDouble(Z) && StringLine::IsDouble(A) && StringLine::IsDouble(I)) && !FILE.eof());
-
- FILE.seekg(posoflinebeforbadline); //return one line before
-
- }
- pos=0;
- if(foundFissile != std::string::npos)
- { string Z;
- string A;
- string I;
-
- int posoflinebeforbadline=0;
- do
- { posoflinebeforbadline = FILE.tellg();
- getline(FILE, line);
-
- stringstream ssline;
- ssline<<line;
- ssline>>Z>>A>>I;
- if(StringLine::IsDouble(Z) && StringLine::IsDouble(A) && StringLine::IsDouble(I) )
- fFissileList.Add(atoi(Z.c_str()),atoi(A.c_str()),atoi(I.c_str()),1.0);
-
-
- }while((StringLine::IsDouble(Z) && StringLine::IsDouble(A) && StringLine::IsDouble(I)) && !FILE.eof());
-
- FILE.seekg(posoflinebeforbadline); //return one line before
-
- }
- pos=0;
- if(foundFertile != std::string::npos)
- { string Z;
- string A;
- string I;
- string prop;
- int posoflinebeforbadline=0;
- do
- { posoflinebeforbadline = FILE.tellg();
- getline(FILE, line);
-
- stringstream ssline;
- ssline<<line;
- ssline>>Z>>A>>I>>prop;
- if(StringLine::IsDouble(Z) && StringLine::IsDouble(A) && StringLine::IsDouble(I) )
- fFertileList.Add(atoi(Z.c_str()),atoi(A.c_str()),atoi(I.c_str()),atof(prop.c_str()) );
-
- }while((StringLine::IsDouble(Z) && StringLine::IsDouble(A) && StringLine::IsDouble(I)) && !FILE.eof());
-
- FILE.seekg(posoflinebeforbadline); //return one line before
- }
-
- }
- }
- else
- {
- ERROR << "Can't find/open file " << fMLPInformationFile << endl;
- exit(1);
- }
-
- /********DEBUG*************************************/
- INFO<<"\tMLP kinf Information : "<<endl;
- INFO<<"\t\tSpecific Power (W/gHM) :"<<fSpecificPower<<endl;
- if(fIsAverageKeff)
- { if((int)fMLP_Time.size()==0)
- { ERROR<<" Time vector is empty"<<endl;
- exit(1);
- }
- INFO<<"\t\tTime (s) :"<<endl;
- for (int i = 0; i < (int)fMLP_Time.size(); ++i)
- INFO<<"\t\t\t"<<fMLP_Time[i]<<endl;
- }
- else
- INFO<<"\t\tMaximal fissile content (molar proportion) :"<<fMaximalContent<<endl;
-
- INFO<<"\t\tZ A I Name (input MLP) :"<<endl;
- map<ZAI ,string >::iterator it;
- for (it= fMapOfTMVAVariableNames.begin();it!=fMapOfTMVAVariableNames.end();it++)
- INFO<<"\t\t\t"<< it->first.Z()<<" "<<it->first.A()<<" "<<it->second<<endl;
- INFO<<"Fissile Liste (Z A I) :"<<endl;
- INFO<<fFissileList.sPrint()<<endl;
- INFO<<"Fertile Liste (Z A I Default Proportion) :"<<endl;
- INFO<<fFertileList.sPrint()<<endl;
-DBGL
-}
-//________________________________________________________________________
-double EQM_MLP_Keff_FBR::GetFissileMolarFraction(IsotopicVector Fissile,IsotopicVector Fertile,double TargetBU)
-{
- if(TargetBU != 0)
- WARNING<<"The third arguement : Burnup has no effect here.";
-
- double FissileContent = 0;
-
- if(fIsAverageKeff)
- FissileContent = GetFissileContent_keffAveragePredictor(Fissile, Fertile);
-
- else
- FissileContent = GetFissileMolarFraction_keffPredictor(Fissile, Fertile);
-
-
-return FissileContent;
-}
-//________________________________________________________________________
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_LIN_PWR_MOX.cxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_LIN_MOX.cxx
similarity index 96%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_LIN_PWR_MOX.cxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_LIN_MOX.cxx
index 90279f07490f9c4e060879161c67e29d91c84c01..a96317ebfa6ab9f4648fad9dfc8d1173e1a91417 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_LIN_PWR_MOX.cxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_LIN_MOX.cxx
@@ -1,4 +1,4 @@
-#include "EQM_LIN_PWR_MOX.hxx"
+#include "EQM_PWR_LIN_MOX.hxx"
#include "CLASSConstante.hxx"
@@ -10,7 +10,7 @@
-EQM_LIN_PWR_MOX::EQM_LIN_PWR_MOX(string WeightPath):EquivalenceModel(new CLASSLogger("EQM_LIN_PWR_MOX.log"))
+EQM_PWR_LIN_MOX::EQM_PWR_LIN_MOX(string WeightPath):EquivalenceModel(new CLASSLogger("EQM_PWR_LIN_MOX.log"))
{
fWeightPath = WeightPath;
@@ -62,7 +62,7 @@ EQM_LIN_PWR_MOX::EQM_LIN_PWR_MOX(string WeightPath):EquivalenceModel(new CLASSLo
}
-EQM_LIN_PWR_MOX::EQM_LIN_PWR_MOX(CLASSLogger* log, string WeightPath):EquivalenceModel(log)
+EQM_PWR_LIN_MOX::EQM_PWR_LIN_MOX(CLASSLogger* log, string WeightPath):EquivalenceModel(log)
{
fWeightPath = WeightPath;
@@ -113,13 +113,13 @@ EQM_LIN_PWR_MOX::EQM_LIN_PWR_MOX(CLASSLogger* log, string WeightPath):Equivalenc
}
-EQM_LIN_PWR_MOX::~EQM_LIN_PWR_MOX()
+EQM_PWR_LIN_MOX::~EQM_PWR_LIN_MOX()
{
}
//________________________________________________________________________
-vector<double> EQM_LIN_PWR_MOX::BuildFuel(double BurnUp, double HMMass,vector<IsotopicVector> FissilArray, vector<IsotopicVector> FertilArray)
+vector<double> EQM_PWR_LIN_MOX::BuildFuel(double BurnUp, double HMMass,vector<IsotopicVector> FissilArray, vector<IsotopicVector> FertilArray)
{
//-----------------------------------------------------------------------------//
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_LIN_PWR_MOX.hxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_LIN_MOX.hxx
similarity index 84%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_LIN_PWR_MOX.hxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_LIN_MOX.hxx
index 851bcd3d74009b36a1b4159495163c71d1ba24c1..3f09d076598d6ffec2db8e52ab2902458ee150ca 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_LIN_PWR_MOX.hxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_LIN_MOX.hxx
@@ -1,5 +1,5 @@
-#ifndef _EQM_LIN_PWR_MOX_HXX
-#define _EQM_LIN_PWR_MOX_HXX
+#ifndef _EQM_PWR_LIN_MOX_HXX
+#define _EQM_PWR_LIN_MOX_HXX
#include "EquivalenceModel.hxx"
@@ -7,7 +7,7 @@
/*!
\file
- \brief Header file for EQM_LIN_PWR_MOX class.
+ \brief Header file for EQM_PWR_LIN_MOX class.
@author BaM
@@ -29,7 +29,7 @@ using namespace std;
*/
//________________________________________________________________________
-class EQM_LIN_PWR_MOX : public EquivalenceModel
+class EQM_PWR_LIN_MOX : public EquivalenceModel
{
public :
/*!
@@ -41,30 +41,30 @@ class EQM_LIN_PWR_MOX : public EquivalenceModel
/// Simple constructor
/*!
- Make a new EQM_LIN_PWR_MOX
+ Make a new EQM_PWR_LIN_MOX
\param WeightPath : Path to the file containing the @f$\alpha_{i}@f$. The file is format as :
@f$PARAM@f$ @f$\alpha_{0}@f$ @f$\alpha_{^{238}Pu}@f$ @f$\alpha_{^{239}Pu}@f$ @f$\alpha_{^{240}Pu}@f$ @f$\alpha_{^{241}Pu}@f$ @f$\alpha_{^{242}Pu}@f$
*/
- EQM_LIN_PWR_MOX(string WeightPath);
+ EQM_PWR_LIN_MOX(string WeightPath);
//}
//{
/// Logger constructor
/*!
- Make a new EQM_LIN_PWR_MOX
+ Make a new EQM_PWR_LIN_MOX
\param log : use for the log
\param WeightPath : Path to the file containing the @f$\alpha_{i}@f$. The file is format as :
@f$PARAM@f$ @f$\alpha_{0}@f$ @f$\alpha_{^{238}Pu}@f$ @f$\alpha_{^{239}Pu}@f$ @f$\alpha_{^{240}Pu}@f$ @f$\alpha_{^{241}Pu}@f$ @f$\alpha_{^{242}Pu}@f$
*/
- EQM_LIN_PWR_MOX(CLASSLogger* log, string WeightPath);
+ EQM_PWR_LIN_MOX(CLASSLogger* log, string WeightPath);
//}
- ~EQM_LIN_PWR_MOX();
+ ~EQM_PWR_LIN_MOX();
//@}
virtual vector<double> BuildFuel(double BurnUp, double HMMass, vector<IsotopicVector> FissilArray, vector<IsotopicVector> FertilArray );
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Kinf.cxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_Kinf.cxx
similarity index 77%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Kinf.cxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_Kinf.cxx
index 339ef76e59418909139d9110105101dfef3543e3..2b4010443047ea1b823294c394489d9a0afa2433 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Kinf.cxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_Kinf.cxx
@@ -1,5 +1,4 @@
-#include "EquivalenceModel.hxx"
-#include "EQM_MLP_Kinf.hxx"
+#include "EQM_PWR_MLP_Kinf.hxx"
#include "CLASSLogger.hxx"
#include "StringLine.hxx"
@@ -18,13 +17,13 @@
//________________________________________________________________________
//
-// EQM_MLP_Kinf
+// EQM_PWR_MLP_Kinf
//
// Equivalenve Model based on multi layer perceptron from TMVA (root cern)
// For REP MOX use
//
//________________________________________________________________________
-EQM_MLP_Kinf::EQM_MLP_Kinf(string WeightPathAlpha0, string WeightPathAlpha1, string WeightPathAlpha2, string InformationFile, int NumOfBatch, double CriticalityThreshold):EquivalenceModel(new CLASSLogger("EQM_MLP_Kinf.log"))
+EQM_PWR_MLP_Kinf::EQM_PWR_MLP_Kinf(string WeightPathAlpha0, string WeightPathAlpha1, string WeightPathAlpha2, string InformationFile, int NumOfBatch, double CriticalityThreshold):EquivalenceModel(new CLASSLogger("EQM_PWR_MLP_Kinf.log"))
{
/**The information file and tmva weight*/
fTMVAWeightPath.push_back(WeightPathAlpha0);
@@ -39,18 +38,18 @@ EQM_MLP_Kinf::EQM_MLP_Kinf(string WeightPathAlpha0, string WeightPathAlpha1, str
SetBurnUpPrecision(0.005);//1 % of the targeted burnup
SetBuildFuelFirstGuess(0.04);//First fissile content guess for the EquivalenceModel::BuildFuel algorithm
- INFO<<"__An equivalence model has been define__"<<endl;
- INFO<<"\tThis model is based on the prediction of kinf"<<endl;
- INFO<<"\tThe TMVA weight files are :"<<endl;
- INFO<<"\t"<<fTMVAWeightPath[0]<<endl;
- INFO<<"\t"<<fTMVAWeightPath[1]<<endl;
- INFO<<"\t"<<fTMVAWeightPath[2]<<endl;
- INFO<<"\tThe Information file is :"<<endl;
- INFO<<"\t"<<fMLPInformationFile<<endl;
+ INFO << "__An equivalence model has been define__" << endl;
+ INFO << "\tThis model is based on the prediction of kinf" << endl;
+ INFO << "\tThe TMVA weight files are :" << endl;
+ INFO << "\t"<<fTMVAWeightPath[0] << endl;
+ INFO << "\t"<<fTMVAWeightPath[1] << endl;
+ INFO << "\t"<<fTMVAWeightPath[2] << endl;
+ INFO << "\tThe Information file is :" << endl;
+ INFO << "\t"<<fMLPInformationFile << endl;
}
//________________________________________________________________________
-EQM_MLP_Kinf::EQM_MLP_Kinf(CLASSLogger* log, string WeightPathAlpha0, string WeightPathAlpha1, string WeightPathAlpha2, string InformationFile, int NumOfBatch, double CriticalityThreshold):EquivalenceModel(log)
+EQM_PWR_MLP_Kinf::EQM_PWR_MLP_Kinf(CLASSLogger* log, string WeightPathAlpha0, string WeightPathAlpha1, string WeightPathAlpha2, string InformationFile, int NumOfBatch, double CriticalityThreshold):EquivalenceModel(log)
{
/**The information file and tmva weight*/
fTMVAWeightPath.push_back(WeightPathAlpha0);
@@ -65,18 +64,18 @@ EQM_MLP_Kinf::EQM_MLP_Kinf(CLASSLogger* log, string WeightPathAlpha0, string Wei
SetBurnUpPrecision(0.005);//1 % of the targeted burnup
SetBuildFuelFirstGuess(0.04);//First fissile content guess for the EquivalenceModel::BuildFuel algorithm
- INFO<<"__An equivalence model has been define__"<<endl;
- INFO<<"\tThis model is based on the prediction of kinf"<<endl;
- INFO<<"\tThe TMVA weight files are :"<<endl;
- INFO<<"\t"<<fTMVAWeightPath[0]<<endl;
- INFO<<"\t"<<fTMVAWeightPath[1]<<endl;
- INFO<<"\t"<<fTMVAWeightPath[2]<<endl;
- INFO<<"\tThe Information file is :"<<endl;
- INFO<<"\t"<<fMLPInformationFile<<endl;
+ INFO << "__An equivalence model has been define__" << endl;
+ INFO << "\tThis model is based on the prediction of kinf" << endl;
+ INFO << "\tThe TMVA weight files are :" << endl;
+ INFO << "\t"<<fTMVAWeightPath[0] << endl;
+ INFO << "\t"<<fTMVAWeightPath[1] << endl;
+ INFO << "\t"<<fTMVAWeightPath[2] << endl;
+ INFO << "\tThe Information file is :" << endl;
+ INFO << "\t"<<fMLPInformationFile << endl;
}
//________________________________________________________________________
-EQM_MLP_Kinf::EQM_MLP_Kinf(string TMVAWeightPath, int NumOfBatch, string InformationFile, double CriticalityThreshold):EquivalenceModel(new CLASSLogger("EQM_MLP_Kinf.log"))
+EQM_PWR_MLP_Kinf::EQM_PWR_MLP_Kinf(string TMVAWeightPath, int NumOfBatch, string InformationFile, double CriticalityThreshold):EquivalenceModel(new CLASSLogger("EQM_PWR_MLP_Kinf.log"))
{
/**The information file and tmva weight*/
fTMVAWeightPath.push_back(TMVAWeightPath);
@@ -93,14 +92,14 @@ EQM_MLP_Kinf::EQM_MLP_Kinf(string TMVAWeightPath, int NumOfBatch, string Inform
SetPCMprecision(10);
SetBuildFuelFirstGuess(0.04);//First fissile content guess for the EquivalenceModel::BuildFuel algorithm
- INFO<<"__An equivalence model has been define__"<<endl;
- INFO<<"\tThis model is based on the prediction of kinf"<<endl;
- INFO<<"\tThe TMVA (weight | information) files are :"<<endl;
- INFO<<"\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )"<<endl;
+ INFO << "__An equivalence model has been define__" << endl;
+ INFO << "\tThis model is based on the prediction of kinf" << endl;
+ INFO << "\tThe TMVA (weight | information) files are :" << endl;
+ INFO << "\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )" << endl;
}
//________________________________________________________________________
-EQM_MLP_Kinf::EQM_MLP_Kinf(CLASSLogger* log, string TMVAWeightPath, int NumOfBatch, string InformationFile, double CriticalityThreshold):EquivalenceModel(log)
+EQM_PWR_MLP_Kinf::EQM_PWR_MLP_Kinf(CLASSLogger* log, string TMVAWeightPath, int NumOfBatch, string InformationFile, double CriticalityThreshold):EquivalenceModel(log)
{
/**The information file and tmva weight*/
@@ -118,16 +117,16 @@ EQM_MLP_Kinf::EQM_MLP_Kinf(CLASSLogger* log, string TMVAWeightPath, int NumOfBa
SetPCMprecision(10);
SetBuildFuelFirstGuess(0.04);//First fissile content guess for the EquivalenceModel::BuildFuel algorithm
- INFO<<"__An equivalence model has been define__"<<endl;
- INFO<<"\tThis model is based on the prediction of kinf"<<endl;
- INFO<<"\tThe TMVA (weight | information) files are :"<<endl;
- INFO<<"\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )"<<endl;
+ INFO << "__An equivalence model has been define__" << endl;
+ INFO << "\tThis model is based on the prediction of kinf" << endl;
+ INFO << "\tThe TMVA (weight | information) files are :" << endl;
+ INFO << "\t"<<"( "<<fTMVAWeightPath[0]<<" | "<<fMLPInformationFile<<" )" << endl;
}
//________________________________________________________________________
-TTree* EQM_MLP_Kinf::CreateTMVAInputTree(IsotopicVector TheFreshfuel, double ThisTime)
+TTree* EQM_PWR_MLP_Kinf::CreateTMVAInputTree(IsotopicVector TheFreshfuel, double ThisTime)
{
/******Create Input data tree to be interpreted by TMVA::Reader***/
TTree* InputTree = new TTree("InTMPKinf", "InTMPKinf");
@@ -176,7 +175,7 @@ TTree* EQM_MLP_Kinf::CreateTMVAInputTree(IsotopicVector TheFreshfuel, double Thi
}
//________________________________________________________________________
-double EQM_MLP_Kinf::ExecuteTMVA(TTree* InputTree,string WeightPath, bool IsTimeDependent)
+double EQM_PWR_MLP_Kinf::ExecuteTMVA(TTree* InputTree,string WeightPath, bool IsTimeDependent)
{
// --- Create the Reader object
@@ -224,7 +223,7 @@ double EQM_MLP_Kinf::ExecuteTMVA(TTree* InputTree,string WeightPath, bool IsTime
return (double)val;//retourn k_{inf}(t=Time)
}
//________________________________________________________________________
-void EQM_MLP_Kinf::GetModelInformation()
+void EQM_PWR_MLP_Kinf::GetModelInformation()
{
DBGL
ifstream FILE(fMLPInformationFile.c_str());
@@ -339,22 +338,22 @@ DBGL
}
/********DEBUG*************************************/
- INFO<<"\tMLP kinf Information : "<<endl;
- INFO<<"\t\tSpecific Power (W/gHM) :"<<fSpecificPower<<endl;
- INFO<<"\t\tMaximal burnup (GWd/tHM) :"<<fMaximalBU<<endl;
- INFO<<"\t\tMaximal fissile content (molar proportion) :"<<fMaximalContent<<endl;
- INFO<<"\t\tZ A I Name (input MLP) :"<<endl;
+ INFO << "\tMLP kinf Information : " << endl;
+ INFO << "\t\tSpecific Power (W/gHM) :"<<fSpecificPower << endl;
+ INFO << "\t\tMaximal burnup (GWd/tHM) :"<<fMaximalBU << endl;
+ INFO << "\t\tMaximal fissile content (molar proportion) :"<<fMaximalContent << endl;
+ INFO << "\t\tZ A I Name (input MLP) :" << endl;
map<ZAI ,string >::iterator it;
for (it= fMapOfTMVAVariableNames.begin();it!=fMapOfTMVAVariableNames.end();it++)
- INFO<<"\t\t\t"<< it->first.Z()<<" "<<it->first.A()<<" "<<it->second<<endl;
- INFO<<"Fissile Liste (Z A I) :"<<endl;
- INFO<<fFissileList.sPrint()<<endl;
- INFO<<"Fertile Liste (Z A I Default Proportion) :"<<endl;
- INFO<<fFertileList.sPrint()<<endl;
+ INFO << "\t\t\t"<< it->first.Z()<<" "<<it->first.A()<<" "<<it->second << endl;
+ INFO << "Fissile Liste (Z A I) :" << endl;
+ INFO << fFissileList.sPrint() << endl;
+ INFO << "Fertile Liste (Z A I Default Proportion) :" << endl;
+ INFO << fFertileList.sPrint() << endl;
DBGL
}
//________________________________________________________________________
-double EQM_MLP_Kinf::GetMaximumBurnUp_MLP(IsotopicVector TheFuel, double TargetBU)
+double EQM_PWR_MLP_Kinf::GetMaximumBurnUp_MLP(IsotopicVector TheFuel, double TargetBU)
{
/**************************************************************************/
//With a dichotomy, the maximal irradiation time (TheFinalTime) is calculated
@@ -384,7 +383,7 @@ double EQM_MLP_Kinf::GetMaximumBurnUp_MLP(IsotopicVector TheFuel, double TargetB
{
if(count > MaximumLoopCount )
{
- ERROR<<"CRITICAL ! Can't manage to predict burnup\nHint : Try to increase the precision on k effective using :\n YourEQM_MLP_Kinf->SetPCMprecision(pcm); with pcm the precision in pcm (default 10) REDUCE IT\n If this message still appear mail to leniau@subatech.in2p3.fr\nor nicolas.thiolliere@subatech.in2p3.fr "<<endl;
+ ERROR<<"CRITICAL ! Can't manage to predict burnup\nHint : Try to increase the precision on k effective using :\n YourEQM_PWR_MLP_Kinf->SetPCMprecision(pcm); with pcm the precision in pcm (default 10) REDUCE IT\n If this message still appear mail to leniau@subatech.in2p3.fr\nor nicolas.thiolliere@subatech.in2p3.fr " << endl;
exit(1);
}
@@ -424,7 +423,7 @@ double EQM_MLP_Kinf::GetMaximumBurnUp_MLP(IsotopicVector TheFuel, double TargetB
return SecondToBurnup(TheFinalTime);
}
//________________________________________________________________________
-double EQM_MLP_Kinf::GetMaximumBurnUp_Pol2(IsotopicVector TheFuel,double TargetBU)
+double EQM_PWR_MLP_Kinf::GetMaximumBurnUp_Pol2(IsotopicVector TheFuel,double TargetBU)
{
TTree* InputTree = CreateTMVAInputTree(TheFuel,-1);
@@ -470,20 +469,20 @@ double EQM_MLP_Kinf::GetMaximumBurnUp_Pol2(IsotopicVector TheFuel,double TargetB
}
else
{
- ERROR<<"No positive solution"<<endl;
+ ERROR<<"No positive solution" << endl;
exit(1);
}
}
else if(Delta==0)
{ T = -B/(2*A);
if(T<0)
- { ERROR<<"No positive solution"<<endl;
+ { ERROR<<"No positive solution" << endl;
exit(1);
}
}
else
{
- WARNING<<"No real solution"<<endl;
+ WARNING<<"No real solution" << endl;
double K_LongTime = Alpha_0+BurnupToSecond(10*TargetBU)*Alpha_1+Alpha_2*BurnupToSecond(10*TargetBU)*BurnupToSecond(10*TargetBU);
DBGV("K_LongTime "<<K_LongTime)
@@ -491,8 +490,8 @@ double EQM_MLP_Kinf::GetMaximumBurnUp_Pol2(IsotopicVector TheFuel,double TargetB
return 10000;
else
{
- ERROR<<" CRITICAL ! Can't find a physical solution ! \n Should not happening please contact BLG :"<<endl;
- ERROR<<"mail to baptiste.leniau@subatech.in2p2.fr\nor nicolas.thiolliere@subatech.in2p3.fr "<<endl;
+ ERROR<<" CRITICAL ! Can't find a physical solution ! \n Should not happening please contact BLG :" << endl;
+ ERROR<<"mail to baptiste.leniau@subatech.in2p2.fr\nor nicolas.thiolliere@subatech.in2p3.fr " << endl;
exit(1);
}
@@ -501,7 +500,7 @@ double EQM_MLP_Kinf::GetMaximumBurnUp_Pol2(IsotopicVector TheFuel,double TargetB
return SecondToBurnup(T);
}
//________________________________________________________________________
-double EQM_MLP_Kinf::GetMaximumBurnUp(IsotopicVector TheFuel, double TargetBU)
+double EQM_PWR_MLP_Kinf::GetMaximumBurnUp(IsotopicVector TheFuel, double TargetBU)
{
double TheBurnUp = -1;
if(fTMVAWeightPath.size()==1)
@@ -511,14 +510,14 @@ double EQM_MLP_Kinf::GetMaximumBurnUp(IsotopicVector TheFuel, double TargetBU)
else
{
- ERROR<<"This method is not yet set up"<<endl;
+ ERROR<<"This method is not yet set up" << endl;
exit(0);
}
return TheBurnUp;
}
//________________________________________________________________________
-double EQM_MLP_Kinf::GetFissileMolarFraction(IsotopicVector Fissil,IsotopicVector Fertil,double TargetBU)
+double EQM_PWR_MLP_Kinf::GetFissileMolarFraction(IsotopicVector Fissil,IsotopicVector Fertil,double TargetBU)
{
//initialization
@@ -536,7 +535,7 @@ double EQM_MLP_Kinf::GetFissileMolarFraction(IsotopicVector Fissil,IsotopicVecto
{
if(count > MaximumLoopCount )
{
- ERROR<<"CRITICAL ! Can't manage to predict fissile content\nHint : Try to decrease the precision on burnup using :\nYourEQM_MLP_Kinf->SetBurnUpPrecision(prop); with prop the precision (default 0.5percent : 0.005) INCREASE IT\nIf this message still appear mail to leniau@subatech.in2p3.fr\nor nicolas.thiolliere@subatech.in2p3.fr "<<endl;
+ ERROR<<"CRITICAL ! Can't manage to predict fissile content\nHint : Try to decrease the precision on burnup using :\nYourEQM_PWR_MLP_Kinf->SetBurnUpPrecision(prop); with prop the precision (default 0.5percent : 0.005) INCREASE IT\nIf this message still appear mail to leniau@subatech.in2p3.fr\nor nicolas.thiolliere@subatech.in2p3.fr " << endl;
exit(1);
}
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Kinf.hxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_Kinf.hxx
similarity index 89%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Kinf.hxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_Kinf.hxx
index f2b8f1a804ee24822b88a01d9de2a929b357d7a0..3f0fab688d06217defe8064d8bd0414907a752d8 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_Kinf.hxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_Kinf.hxx
@@ -1,12 +1,12 @@
-#ifndef _EQM_MLP_Kinf_HXX
-#define _EQM_MLP_Kinf_HXX
+#ifndef _EQM_PWR_MLP_Kinf_HXX
+#define _EQM_PWR_MLP_Kinf_HXX
#include "EquivalenceModel.hxx"
#include "TTree.h"
/*!
\file
- \brief Header file for EQM_MLP_Kinf class.
+ \brief Header file for EQM_PWR_MLP_Kinf class.
@author BLG
@@ -38,7 +38,7 @@ in non simulated devices such as control rods and mixing grid.
//________________________________________________________________________
-class EQM_MLP_Kinf : public EquivalenceModel
+class EQM_PWR_MLP_Kinf : public EquivalenceModel
{
public :
/*!
@@ -50,7 +50,7 @@ class EQM_MLP_Kinf : public EquivalenceModel
/// Polynnomial 2nd order constructor @f$k_{\infty} = \alpha_{0} + \alpha_{1}t + \alpha_{2}t^{2}@f$
/// @f$\alpha_{0}@f$, @f$\alpha_{1}@f$, @f$\alpha_{2}@f$ are predict by 3 MLP (one for each)
/*!
- Create a EQM_MLP_Kinf
+ Create a EQM_PWR_MLP_Kinf
\param TMVAWeightPath0 : PAth to the .xml file containing neural network informations for @f$\alpha_{0}@f$ prediction : PATH/TMVAWeight.xml (total path to tmva weight)
\param TMVAWeightPath1 : PAth to the .xml file containing neural network informations for @f$\alpha_{1}@f$ prediction: PATH/TMVAWeight.xml (total path to tmva weight)
\param TMVAWeightPath2 : PAth to the .xml file containing neural network informations for @f$\alpha_{2}@f$ prediction: PATH/TMVAWeight.xml (total path to tmva weight)
@@ -58,13 +58,13 @@ class EQM_MLP_Kinf : public EquivalenceModel
\param NumOfBatch : Number of batch for the loading plan (often 3 or 4 for PWR)
\param CriticalityThreshold : Threshold for the @f$k_{\infty}@f$ (see detailed description)
*/
- EQM_MLP_Kinf(string WeightPathAlpha0, string WeightPathAlpha1, string WeightPathAlpha2, string InformationFile, int NumOfBatch, double CriticalityThreshold = 1.01);
+ EQM_PWR_MLP_Kinf(string WeightPathAlpha0, string WeightPathAlpha1, string WeightPathAlpha2, string InformationFile, int NumOfBatch, double CriticalityThreshold = 1.01);
//}
//{
/// Polynnomial 2nd order constructor @f$k_{\infty} = \alpha_{0} + \alpha_{1}t + \alpha_{2}t^{2}@f$
/// @f$\alpha_{0}@f$, @f$\alpha_{1}@f$, @f$\alpha_{2}@f$ are predict by 3 MLP (one for each)
/*!
- Create a EQM_MLP_Kinf
+ Create a EQM_PWR_MLP_Kinf
\param log : use for log
\param TMVAWeightPath0 : PAth to the .xml file containing neural network informations for @f$\alpha_{0}@f$ prediction : PATH/TMVAWeight.xml (total path to tmva weight)
\param TMVAWeightPath1 : PAth to the .xml file containing neural network informations for @f$\alpha_{1}@f$ prediction: PATH/TMVAWeight.xml (total path to tmva weight)
@@ -73,31 +73,31 @@ class EQM_MLP_Kinf : public EquivalenceModel
\param NumOfBatch : Number of batch for the loading plan (often 3 or 4 for PWR)
\param CriticalityThreshold : Threshold for the @f$k_{\infty}@f$ (see detailed description)
*/
- EQM_MLP_Kinf(CLASSLogger* log, string WeightPathAlpha0, string WeightPathAlpha1, string WeightPathAlpha2, string InformationFile, int NumOfBatch, double CriticalityThreshold = 1.01 );
+ EQM_PWR_MLP_Kinf(CLASSLogger* log, string WeightPathAlpha0, string WeightPathAlpha1, string WeightPathAlpha2, string InformationFile, int NumOfBatch, double CriticalityThreshold = 1.01 );
//}
//{
/// Neural network predictor. The kinf(t) is predicted with a MLP
/*!
- Create a EQM_MLP_Kinf
+ Create a EQM_PWR_MLP_Kinf
\param TMVAWeightPath : PAth to the .xml file containing neural network informations : PATH/TMVAWeight.xml (total path to tmva weight)
\param NumOfBatch : Number of batch for the loading plan (often 3 or 4 for PWR)
\param InformationFile : Total path to the file containing time steps, fissile and ferile list (ante and post fabrication time cooling). Default is the same total path as TMVAWeightPath but extension is replaced by .nfo
\param CriticalityThreshold : Threshold for the @f$k_{\infty}@f$ (see detailed description)
*/
- EQM_MLP_Kinf(string TMVAWeightPath,int NumOfBatch, string InformationFile="", double CriticalityThreshold=1.01);
+ EQM_PWR_MLP_Kinf(string TMVAWeightPath,int NumOfBatch, string InformationFile="", double CriticalityThreshold=1.01);
//}
//{
/// Neural network predictor. The kinf(t) is predicted with a MLP
/*!
- Create a EQM_MLP_Kinf
+ Create a EQM_PWR_MLP_Kinf
\param log : use for log
\param TMVAWeightPath : PAth to the .xml file containing neural network informations : PATH/TMVAWeight.xml (total path to tmva weight)
\param NumOfBatch : Number of batch for the loading plan (often 3 or 4 for PWR)
\param InformationFile : Total path to the file containing time steps, fissile and ferile list (ante and post fabrication time cooling). Default is the same total path as TMVAWeightPath but extension is replaced by .nfo
\param CriticalityThreshold : Threshold for the @f$k_{\infty}@f$ (see detailed description)
*/
- EQM_MLP_Kinf(CLASSLogger* log, string TMVAWeightPath,int NumOfBatch, string InformationFile="", double CriticalityThreshold=1.01);
+ EQM_PWR_MLP_Kinf(CLASSLogger* log, string TMVAWeightPath,int NumOfBatch, string InformationFile="", double CriticalityThreshold=1.01);
//}
//@}
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_PWR_MOX.cxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_MOX.cxx
similarity index 92%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_PWR_MOX.cxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_MOX.cxx
index a09d3e904bddffe077798b901c5ed5f54c118afd..f547fc880a8eb1940620db3bb26aeeaeb620f856 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_PWR_MOX.cxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_MOX.cxx
@@ -1,5 +1,5 @@
#include "EquivalenceModel.hxx"
-#include "EQM_MLP_PWR_MOX.hxx"
+#include "EQM_PWR_MLP_MOX.hxx"
#include "CLASSLogger.hxx"
#include "StringLine.hxx"
@@ -18,14 +18,14 @@
//________________________________________________________________________
//
-// EQM_MLP_PWR_MOX
+// EQM_PWR_MLP_MOX
//
// Equivalenve Model based on multi layer perceptron from TMVA (root cern)
// For REP MOX use
//
//________________________________________________________________________
-EQM_MLP_PWR_MOX::EQM_MLP_PWR_MOX(string TMVAWeightPath):EquivalenceModel(new CLASSLogger("EQM_MLP_PWR_MOX.log"))
+EQM_PWR_MLP_MOX::EQM_PWR_MLP_MOX(string TMVAWeightPath):EquivalenceModel(new CLASSLogger("EQM_PWR_MLP_MOX.log"))
{
fTMVAWeightPath = TMVAWeightPath;
@@ -52,7 +52,7 @@ EQM_MLP_PWR_MOX::EQM_MLP_PWR_MOX(string TMVAWeightPath):EquivalenceModel(new CLA
}
//________________________________________________________________________
-EQM_MLP_PWR_MOX::EQM_MLP_PWR_MOX(CLASSLogger* log, string TMVAWeightPath):EquivalenceModel(log)
+EQM_PWR_MLP_MOX::EQM_PWR_MLP_MOX(CLASSLogger* log, string TMVAWeightPath):EquivalenceModel(log)
{
fTMVAWeightPath = TMVAWeightPath;
@@ -79,7 +79,7 @@ EQM_MLP_PWR_MOX::EQM_MLP_PWR_MOX(CLASSLogger* log, string TMVAWeightPath):Equiva
}
//________________________________________________________________________
-TTree* EQM_MLP_PWR_MOX::CreateTMVAInputTree(IsotopicVector Fissil,IsotopicVector Fertil,double BurnUp)
+TTree* EQM_PWR_MLP_MOX::CreateTMVAInputTree(IsotopicVector Fissil,IsotopicVector Fertil,double BurnUp)
{
TTree* InputTree = new TTree("EQTMP", "EQTMP");
float Pu8 = 0;
@@ -137,7 +137,7 @@ TTree* EQM_MLP_PWR_MOX::CreateTMVAInputTree(IsotopicVector Fissil,IsotopicVector
return InputTree;
}
//________________________________________________________________________
-double EQM_MLP_PWR_MOX::ExecuteTMVA(TTree* theTree)
+double EQM_PWR_MLP_MOX::ExecuteTMVA(TTree* theTree)
{
// --- Create the Reader object
TMVA::Reader *reader = new TMVA::Reader( "Silent" );
@@ -177,7 +177,7 @@ double EQM_MLP_PWR_MOX::ExecuteTMVA(TTree* theTree)
return (double)val; //retourne teneur
}
//________________________________________________________________________
-double EQM_MLP_PWR_MOX::GetFissileMolarFraction(IsotopicVector Fissil,IsotopicVector Fertil,double BurnUp)
+double EQM_PWR_MLP_MOX::GetFissileMolarFraction(IsotopicVector Fissil,IsotopicVector Fertil,double BurnUp)
{DBGL
return ExecuteTMVA(CreateTMVAInputTree(Fissil,Fertil,BurnUp));
}
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_PWR_MOX.hxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_MOX.hxx
similarity index 84%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_PWR_MOX.hxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_MOX.hxx
index 50fd621d0a34838e9c4379efbaabc1455efdafab..0512a47cabc0c37e8affe3e328c99ba4a68725b2 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_MLP_PWR_MOX.hxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_MLP_MOX.hxx
@@ -1,12 +1,12 @@
-#ifndef _EQM_MLP_PWR_MOX_HXX
-#define _EQM_MLP_PWR_MOX_HXX
+#ifndef _EQM_PWR_MLP_MOX_HXX
+#define _EQM_PWR_MLP_MOX_HXX
#include "EquivalenceModel.hxx"
#include "TTree.h"
/*!
\file
- \brief Header file for EQM_MLP_PWR_MOX class.
+ \brief Header file for EQM_PWR_MLP_MOX class.
@author BLG
@@ -29,7 +29,7 @@ using namespace std;
//________________________________________________________________________
-class EQM_MLP_PWR_MOX : public EquivalenceModel
+class EQM_PWR_MLP_MOX : public EquivalenceModel
{
public :
/*!
@@ -40,20 +40,20 @@ class EQM_MLP_PWR_MOX : public EquivalenceModel
//{
/// normal constructor
/*!
- Create a EQM_MLP_PWR_MOX
+ Create a EQM_PWR_MLP_MOX
\param TMVAWeightPath : PAth to the .xml file containing neural network informations : PATH/TMVAWeight.xml (total path to tmva weight)
*/
- EQM_MLP_PWR_MOX(string TMVAWeightPath);
+ EQM_PWR_MLP_MOX(string TMVAWeightPath);
//}
//{
/// Logger constructor
/*!
- Create a EQM_MLP_PWR_MOX
+ Create a EQM_PWR_MLP_MOX
\param log : use for log
\param TMVAWeightPath : PAth to the .xml file containing neural network informations : PATH/TMVAWeight.xml (total path to tmva weight)
*/
- EQM_MLP_PWR_MOX(CLASSLogger* log, string TMVAWeightPath);
+ EQM_PWR_MLP_MOX(CLASSLogger* log, string TMVAWeightPath);
//}
//@}
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_POL_PWR_UO2.cxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_POL_UO2.cxx
similarity index 83%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_POL_PWR_UO2.cxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_POL_UO2.cxx
index 17e13ab960304013ed104b89ec8a44a5e1d1872c..e74038800ae6bc426654e75be373e7cbcc0a99f3 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_POL_PWR_UO2.cxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_POL_UO2.cxx
@@ -1,11 +1,11 @@
#include "EquivalenceModel.hxx"
-#include "EQM_POL_PWR_UO2.hxx"
+#include "EQM_PWR_POL_UO2.hxx"
#include "CLASSLogger.hxx"
#include "StringLine.hxx"
// ________________________________________________________________________
-// EQM_POL_PWR_UO2
+// EQM_PWR_POL_UO2
//
// ________________________________________________________________________
@@ -13,7 +13,7 @@
//Constructor(s)
-EQM_POL_PWR_UO2::EQM_POL_PWR_UO2(string PathToWeightFile):EquivalenceModel(new CLASSLogger("EQM_POL_PWR_UO2.log"))
+EQM_PWR_POL_UO2::EQM_PWR_POL_UO2(string PathToWeightFile):EquivalenceModel(new CLASSLogger("EQM_PWR_POL_UO2.log"))
{
// Fertile
@@ -28,7 +28,7 @@ EQM_POL_PWR_UO2::EQM_POL_PWR_UO2(string PathToWeightFile):EquivalenceModel(new C
}
// _______________________________________________________________________
-EQM_POL_PWR_UO2::EQM_POL_PWR_UO2(CLASSLogger* log,string PathToWeightFile):EquivalenceModel(log)
+EQM_PWR_POL_UO2::EQM_PWR_POL_UO2(CLASSLogger* log,string PathToWeightFile):EquivalenceModel(log)
{
// Fertile
@@ -43,7 +43,7 @@ EQM_POL_PWR_UO2::EQM_POL_PWR_UO2(CLASSLogger* log,string PathToWeightFile):Equiv
}
// _______________________________________________________________________
-void EQM_POL_PWR_UO2::ReadWeightFile(string PathToWeightFile)
+void EQM_PWR_POL_UO2::ReadWeightFile(string PathToWeightFile)
{
ifstream DataDB(PathToWeightFile.c_str()); // Open the File
if(!DataDB)
@@ -66,7 +66,7 @@ void EQM_POL_PWR_UO2::ReadWeightFile(string PathToWeightFile)
INFO <<"\t U enrichment = "<<fParam_Bu_0<<" + "<<fParam_Bu<<"*Burnup + "<< fParam_BuSquare<<"*Burnup*Burnup"<<endl;
}
// _______________________________________________________________________
-double EQM_POL_PWR_UO2::GetFissileMolarFraction ( IsotopicVector Fissil , IsotopicVector Fertil , double BurnUp )
+double EQM_PWR_POL_UO2::GetFissileMolarFraction ( IsotopicVector Fissil , IsotopicVector Fertil , double BurnUp )
{
return fParam_Bu_0 + fParam_Bu*BurnUp + fParam_BuSquare*BurnUp*BurnUp ;
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_POL_PWR_UO2.hxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_POL_UO2.hxx
similarity index 84%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_POL_PWR_UO2.hxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_POL_UO2.hxx
index 6f8631669e2336ae4c806b6a630a8e2fece9f1b0..df02d91996944a1f0c05a87495b71585f100c738 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_POL_PWR_UO2.hxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_POL_UO2.hxx
@@ -1,5 +1,5 @@
-#ifndef _EQM_POL_PWR_UO2_HXX
-#define _EQM_POL_PWR_UO2_HXX
+#ifndef _EQM_PWR_POL_UO2_HXX
+#define _EQM_PWR_POL_UO2_HXX
#include "EquivalenceModel.hxx"
@@ -9,7 +9,7 @@ using namespace std;
//! Define an EquivalenceModel based on a polynomial fit
/*!
- Defines a EQM_POL_PWR_UO2
+ Defines a EQM_PWR_POL_UO2
It returns the @f$^{235}U@f$ enrichment e according to this polynom :
@f$e=\alpha_{0} + \alpha_{1}\cdot Burnup + \alpha_{2}\cdot Burnup \cdot Burnup @f$
@@ -23,7 +23,7 @@ using namespace std;
-class EQM_POL_PWR_UO2 : public EquivalenceModel
+class EQM_PWR_POL_UO2 : public EquivalenceModel
{
public:
@@ -35,22 +35,22 @@ public:
//{
/// normal constructor
/*!
- Create a EQM_POL_PWR_UO2
+ Create a EQM_PWR_POL_UO2
\param PathToWeightFile : Path to the file containing the @f$\alpha_{i}@f$
Format : @f$PARAM@f$ @f$\alpha_{0}@f$ @f$\alpha_{1}@f$ @f$\alpha_{2}@f$
*/
- EQM_POL_PWR_UO2(string PathToWeightFile);
+ EQM_PWR_POL_UO2(string PathToWeightFile);
//}
//{
/// logger constructor
/*!
- Create a EQM_POL_PWR_UO2
+ Create a EQM_PWR_POL_UO2
\param log : Use for the log
\param PathToWeightFile : Path to the file containing the @f$\alpha_{i}@f$
Format : @f$PARAM@f$ @f$\alpha_{0}@f$ @f$\alpha_{1}@f$ @f$\alpha_{2}@f$
*/
- EQM_POL_PWR_UO2(CLASSLogger* log, string PathToWeightFile);
+ EQM_PWR_POL_UO2(CLASSLogger* log, string PathToWeightFile);
//}
//@}
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_QUAD_PWR_MOX.cxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_QUAD_MOX.cxx
similarity index 90%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_QUAD_PWR_MOX.cxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_QUAD_MOX.cxx
index 7632745c08e3e9e45ba8b0882e1137bb02e001cf..6fe95f955b9a90a2d9c2f5ca770f642044111eaa 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_QUAD_PWR_MOX.cxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_QUAD_MOX.cxx
@@ -1,4 +1,4 @@
-#include "EQM_QUAD_PWR_MOX.hxx"
+#include "EQM_PWR_QUAD_MOX.hxx"
#include <vector>
@@ -8,7 +8,7 @@
-EQM_QUAD_PWR_MOX::EQM_QUAD_PWR_MOX(string WeightPath):EquivalenceModel(new CLASSLogger("EQM_QUAD_PWR_MOX.log"))
+EQM_PWR_QUAD_MOX::EQM_PWR_QUAD_MOX(string WeightPath):EquivalenceModel(new CLASSLogger("EQM_PWR_QUAD_MOX.log"))
{
fWeightPath = WeightPath;
@@ -49,7 +49,7 @@ EQM_QUAD_PWR_MOX::EQM_QUAD_PWR_MOX(string WeightPath):EquivalenceModel(new CLASS
}
-EQM_QUAD_PWR_MOX::EQM_QUAD_PWR_MOX(CLASSLogger* log, string WeightPath):EquivalenceModel(log)
+EQM_PWR_QUAD_MOX::EQM_PWR_QUAD_MOX(CLASSLogger* log, string WeightPath):EquivalenceModel(log)
{
fWeightPath = WeightPath;
@@ -91,7 +91,7 @@ EQM_QUAD_PWR_MOX::EQM_QUAD_PWR_MOX(CLASSLogger* log, string WeightPath):Equivale
-EQM_QUAD_PWR_MOX::~EQM_QUAD_PWR_MOX()
+EQM_PWR_QUAD_MOX::~EQM_PWR_QUAD_MOX()
{
}
@@ -99,7 +99,7 @@ EQM_QUAD_PWR_MOX::~EQM_QUAD_PWR_MOX()
-double EQM_QUAD_PWR_MOX::GetFissileMolarFraction(IsotopicVector Fissile,IsotopicVector Fertile,double BurnUp)
+double EQM_PWR_QUAD_MOX::GetFissileMolarFraction(IsotopicVector Fissile,IsotopicVector Fertile,double BurnUp)
{
diff --git a/source/branches/BaM_Dev/Model/Equivalence/EQM_QUAD_PWR_MOX.hxx b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_QUAD_MOX.hxx
similarity index 84%
rename from source/branches/BaM_Dev/Model/Equivalence/EQM_QUAD_PWR_MOX.hxx
rename to source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_QUAD_MOX.hxx
index 365b75d3935fc78c44ca40fe179af747865d1d74..7906fa90f146feee9eac8f9164c1e76876662e74 100644
--- a/source/branches/BaM_Dev/Model/Equivalence/EQM_QUAD_PWR_MOX.hxx
+++ b/source/branches/BaM_Dev/Model/Equivalence/EQM_PWR_QUAD_MOX.hxx
@@ -1,5 +1,5 @@
-#ifndef _EQM_QUAD_PWR_MOX_HXX
-#define _EQM_QUAD_PWR_MOX_HXX
+#ifndef _EQM_PWR_QUAD_MOX_HXX
+#define _EQM_PWR_QUAD_MOX_HXX
#include "EquivalenceModel.hxx"
@@ -7,7 +7,7 @@
/*!
\file
- \brief Header file for EQM_QUAD_PWR_MOX class.
+ \brief Header file for EQM_PWR_QUAD_MOX class.
@author BaM
@@ -31,7 +31,7 @@ using namespace std;
*/
//________________________________________________________________________
-class EQM_QUAD_PWR_MOX : public EquivalenceModel
+class EQM_PWR_QUAD_MOX : public EquivalenceModel
{
public :
@@ -43,27 +43,27 @@ class EQM_QUAD_PWR_MOX : public EquivalenceModel
//{
/// normal constructor
/*!
- Create a EQM_POL_PWR_UO2
+ Create a EQM_PWR_POL_UO2
\param WeightPath : Path to the file containing the @f$\alpha_{i}@f$
Format : @f$PARAM@f$ @f$\alpha_{^{238}Pu}@f$ @f$\alpha_{^{238}Pu ^{238}Pu}@f$ @f$\alpha_{^{238}Pu ^{239}Pu}@f$ .... @f$\alpha_{^{238}Pu ^{242}Pu}@f$ @f$\alpha_{^{239}Pu}@f$ ...
@f$\alpha_{^{242}Pu}@f$ @f$\alpha_{^{242}Pu ^{242}Pu}@f$ @f$\alpha_{0}@f$
*/
- EQM_QUAD_PWR_MOX(string WeightPath);
+ EQM_PWR_QUAD_MOX(string WeightPath);
//}
//{
/// Logger constructor
/*!
- Create a EQM_POL_PWR_UO2
+ Create a EQM_PWR_POL_UO2
\param log : Use for the log
\param WeightPath : Path to the file containing the @f$\alpha_{i}@f$
Format : @f$PARAM@f$ @f$\alpha_{^{238}Pu}@f$ @f$\alpha_{^{238}Pu ^{238}Pu}@f$ @f$\alpha_{^{238}Pu ^{239}Pu}@f$ .... @f$\alpha_{^{238}Pu ^{242}Pu}@f$ @f$\alpha_{^{239}Pu}@f$ ...
@f$\alpha_{^{242}Pu}@f$ @f$\alpha_{^{242}Pu ^{242}Pu}@f$ @f$\alpha_{0}@f$
*/
- EQM_QUAD_PWR_MOX(CLASSLogger* log, string WeightPath);
+ EQM_PWR_QUAD_MOX(CLASSLogger* log, string WeightPath);
//}
- ~EQM_QUAD_PWR_MOX();
+ ~EQM_PWR_QUAD_MOX();
//@}
virtual double GetFissileMolarFraction(IsotopicVector Fissil,IsotopicVector Fertil,double BurnUp);
diff --git a/source/branches/BaM_Dev/Model/XS/XSM_CLOSEST.cxx b/source/branches/BaM_Dev/Model/XS/XSM_CLOSEST.cxx
index c8be61c8c8086d38760fc12404e6f82d03802fd3..b6f9bb5f0ba51b96299054df354fd36952db6d1f 100644
--- a/source/branches/BaM_Dev/Model/XS/XSM_CLOSEST.cxx
+++ b/source/branches/BaM_Dev/Model/XS/XSM_CLOSEST.cxx
@@ -117,7 +117,7 @@ void XSM_CLOSEST::ReadDataBase()
//________________________________________________________________________
//________________________________________________________________________
//________________________________________________________________________
-/* Distance Calculation */
+/* Distance Calculation */
//________________________________________________________________________
//________________________________________________________________________
//________________________________________________________________________
diff --git a/source/branches/BaM_Dev/Model/XS/XSM_MLP.cxx b/source/branches/BaM_Dev/Model/XS/XSM_MLP.cxx
index 38f3fcc5a2ddf09b9b31010ae2e8f2055e6bffbd..078fa4d022e58c6a93e2f4e6252fbd53b416ef8a 100644
--- a/source/branches/BaM_Dev/Model/XS/XSM_MLP.cxx
+++ b/source/branches/BaM_Dev/Model/XS/XSM_MLP.cxx
@@ -82,15 +82,17 @@ XSM_MLP::~XSM_MLP()
}
+//________________________________________________________________________
void XSM_MLP::LoadKeyword()
{
DBGL
- fDKeyword.insert( pair<string, DMthPtr>( "k_timestep", & XSM_MLP::ReadTimeSteps));
- fDKeyword.insert( pair<string, DMthPtr>( "k_zainame", & XSM_MLP::ReadZAIName) );
+ fDKeyword.insert( pair<string, XS_MLP_DMthPtr>( "k_timestep", & XSM_MLP::ReadTimeSteps));
+ fDKeyword.insert( pair<string, XS_MLP_DMthPtr>( "k_zainame", & XSM_MLP::ReadZAIName) );
DBGL
}
+//________________________________________________________________________
void XSM_MLP::ReadZAIName(const string &line)
{
DBGL
@@ -113,6 +115,7 @@ void XSM_MLP::ReadZAIName(const string &line)
DBGL
}
+//________________________________________________________________________
void XSM_MLP::ReadTimeSteps(const string &line)
{
DBGL
@@ -138,7 +141,7 @@ void XSM_MLP::ReadLine(string line)
int pos = 0;
string keyword = tlc(StringLine::NextWord(line, pos, ' '));
- map<string, DMthPtr>::iterator it = fDKeyword.find(keyword);
+ map<string, XS_MLP_DMthPtr>::iterator it = fDKeyword.find(keyword);
if(it != fDKeyword.end())
(this->*(it->second))( line );
@@ -147,32 +150,6 @@ void XSM_MLP::ReadLine(string line)
}
-
-
-
-//________________________________________________________________________
-/*void XSM_MLP::GetDataBaseInformation()
-{
- INFO<<"\tMLP XS Data Base Information : "<<endl;
- INFO<<"\t\tHeavy Metal (t) :"<<fDBHMMass<<endl;
- INFO<<"\t\tThermal Power (W) :"<<fDBPower<<endl;
- INFO<<"\t\tTime (s) :"<<endl;
- for (int i = 0; i < (int)fMLP_Time.size(); ++i)
- INFO<<"\t\t\t"<<fMLP_Time[i]<<endl;
- INFO<<"\t\tZ A I Name (input MLP) :"<<endl;
-
- map<ZAI ,string >::iterator it;
-
- for (it= fMapOfTMVAVariableNames.begin();it!=fMapOfTMVAVariableNames.end();it++)
- INFO<<"\t\t\t"<< it->first.Z()<<" "<<it->first.A()<<" "<<it->second<<endl;
-
- INFO<<"\t\tFuel range"<<endl;
- for (map<ZAI,pair<double,double> >::iterator it_dom = fZAILimits.begin();it_dom!=fZAILimits.end();it_dom++)
- INFO<<"\t\t\t"<< it_dom->second.first<<" <= "<<it_dom->first.Z()<<" "<<it_dom->first.A()<<" "<<it_dom->first.I()<<" <= "<<it_dom->second.second<<endl;;
-
-
-}
- */
//________________________________________________________________________
void XSM_MLP::GetMLPWeightFiles()
diff --git a/source/branches/BaM_Dev/Model/XS/XSM_MLP.hxx b/source/branches/BaM_Dev/Model/XS/XSM_MLP.hxx
index 10001e3102e9b5f02b38423b338ee29f829a7345..bdefbf06970b69e071209c2a3e7a353c8ba3eebb 100644
--- a/source/branches/BaM_Dev/Model/XS/XSM_MLP.hxx
+++ b/source/branches/BaM_Dev/Model/XS/XSM_MLP.hxx
@@ -27,7 +27,7 @@ using namespace std;
class XSM_MLP;
#ifndef __CINT__
-typedef void (XSM_MLP::*DMthPtr)( const string & ) ;
+typedef void (XSM_MLP::*XS_MLP_DMthPtr)( const string & ) ;
#endif
//-----------------------------------------------------------------------------//
//! Defines a XSModel getting mean cross sections from neural network execution
@@ -78,15 +78,44 @@ class XSM_MLP : public XSModel
~XSM_MLP();
//@}
+ /*!
+ \name Reading NFO related Method
+ */
+ //@{
+
+ //{
+ /// LoadKeyword() : make the correspondance between keyword and reading method
void LoadKeyword();
+ //}
+ //{
+ /// ReadTimeSteps : read the time step of the model
+ /*!
+ \param line : line suppossed to contain the time step information starts with "k_timestep" keyword
+ */
void ReadTimeSteps(const string &line);
+ //}
+
+ //{
+ /// ReadZAIName : read the zai name in the TMWA MLP model
+ /*!
+ \param line : line suppossed to contain the ZAI name starts with "k_zainame" keyword
+ */
void ReadZAIName(const string &line);
+ //}
+ //{
+ /// ReadLine : read a line
+ /*!
+ \param line : line to read
+ */
+ void ReadLine(string line);
+ //}
+
+ //@}
EvolutionData GetCrossSections(IsotopicVector IV,double t=0); //!< Return calculated cross section by the MLP regression
- void ReadLine(string line);
private :
@@ -114,7 +143,7 @@ class XSM_MLP : public XSModel
map<ZAI,string> fMapOfTMVAVariableNames;//!< List of TMVA input variable names (read from fMLPInformationFile ) , name depends on the training step
#ifndef __CINT__
- map<string, DMthPtr> fDKeyword;
+ map<string, XS_MLP_DMthPtr> fDKeyword;
#endif
};
diff --git a/source/branches/BaM_Dev/include/EquivalenceModel.hxx b/source/branches/BaM_Dev/include/EquivalenceModel.hxx
index deaf6be75b7b21854ac2e9cd6fb38c67ba39fa8b..61739c1c566d0cc61a3df965cdcf7de56f4d4d67 100644
--- a/source/branches/BaM_Dev/include/EquivalenceModel.hxx
+++ b/source/branches/BaM_Dev/include/EquivalenceModel.hxx
@@ -22,7 +22,7 @@ using namespace std;
class EquivalenceModel;
#ifndef __CINT__
-typedef void (EquivalenceModel::*EQMthPtr)( const string & );
+typedef void (EquivalenceModel::*EQM_MthPtr)( const string & );
#endif
//-----------------------------------------------------------------------------//
@@ -35,11 +35,11 @@ typedef void (EquivalenceModel::*EQMthPtr)( const string & );
\warning
Never instantiate EquivalenceModel in your CLASS input but it's derivated class
- @see EQM_BakerRoss_FBR_MOX
- @see EQM_LIN_PWR_MOX
- @see EQM_MLP_PWR_MOX
- @see EQM_POL_PWR_UO2
- @see EQM_QUAD_PWR_MOX
+ @see EQM_FBR_BakerRoss_MOX
+ @see EQM_PWR_LIN_MOX
+ @see EQM_PWR_MLP_MOX
+ @see EQM_PWR_POL_UO2
+ @see EQM_PWR_QUAD_MOX
@author BaM
@author BLG
@@ -95,7 +95,7 @@ class EquivalenceModel : public CLASSObject
double GetRelativMassPrecision() const { return fRelativMassPrecision; } //!< Mass precision
int GetMaxInterration() const { return fMaxInterration; } //!< Max iterration in build fueld algorythm
- double GetActualFissileContent() const { return fActualFissileContent; } //!< Get the fissile content at the actual dichotomy step (usefull for EQM_MLP_Kinf)
+ double GetActualFissileContent() const { return fActualFissileContent; } //!< Get the fissile content at the actual dichotomy step (usefull for EQM_PWR_MLP_Kinf)
void SetFertileList(IsotopicVector IV) {fFertileList = IV;}//!<set the fertile list
void SetFissileList(IsotopicVector IV) {fFissileList = IV;}//!<set the fissile list
@@ -103,9 +103,12 @@ class EquivalenceModel : public CLASSObject
void SetRelativMassPrecision( double val) { fRelativMassPrecision = val; } //!< Mass precision
void SetMaxInterration(int val) { fMaxInterration = val; } //!< Max iterration in build fueld algorythm
- virtual void LoadKeyword();
+
void ReadNFO();
virtual void ReadLine(string line);
+
+
+ virtual void LoadKeyword();
void ReadZAIlimits(const string &line);
void ReadType(const string &line);
//@}
@@ -123,10 +126,10 @@ class EquivalenceModel : public CLASSObject
//!< if no stock are provided the fuel will not be made
double fFirstGuessFissilContent;//!< fissile content for BuildFuel initialization (in weight proportion)
- double fActualFissileContent; //!< fissile content at the actual dichotomy step (usefull for EQM_MLP_Kinf)
+ double fActualFissileContent; //!< fissile content at the actual dichotomy step (usefull for EQM_PWR_MLP_Kinf)
- private :
+ protected :
/*!
\name Algorithm parameters
*/
@@ -147,7 +150,7 @@ class EquivalenceModel : public CLASSObject
//@}
#ifndef __CINT__
- map<string, EQMthPtr> fKeyword;
+ map<string, EQM_MthPtr> fKeyword;
#endif
bool freaded;
diff --git a/source/branches/BaM_Dev/include/XSModel.hxx b/source/branches/BaM_Dev/include/XSModel.hxx
index 0c1b755d7808ca8bf1c37664258a00759ee664ef..524f9aa29b6a593b65fc811ac4ef1b756fb6122c 100644
--- a/source/branches/BaM_Dev/include/XSModel.hxx
+++ b/source/branches/BaM_Dev/include/XSModel.hxx
@@ -23,7 +23,7 @@ class IsotopicVector;
class XSModel;
#ifndef __CINT__
-typedef void (XSModel::*MthPtr)( const string & ) ;
+typedef void (XSModel::*XSM_MthPtr)( const string & ) ;
#endif
//-----------------------------------------------------------------------------//
@@ -116,7 +116,7 @@ class XSModel : public CLASSObject
map< ZAI, pair<double,double> > fZAILimits; //!< Fresh fuel range : map<ZAI<min edge ,max edge >>
#ifndef __CINT__
- map<string, MthPtr> fKeyword;
+ map<string, XSM_MthPtr> fKeyword;
#endif
int fZAIThreshold; //!< Z threshold for handling nuclei mean cross section (take only ZAI reaction of Z>=fZAIThresold)
diff --git a/source/branches/BaM_Dev/src/DecayDataBank.cxx b/source/branches/BaM_Dev/src/DecayDataBank.cxx
index dd800660b3d864bab368775d03fc9ee78162f739..93dde70fa2cf0b0894f23b840af09a6bceeaaeeb 100644
--- a/source/branches/BaM_Dev/src/DecayDataBank.cxx
+++ b/source/branches/BaM_Dev/src/DecayDataBank.cxx
@@ -139,6 +139,7 @@ DBGL
return returnIV;
}
+//________________________________________________________________________
bool DecayDataBank::IsDefine(const ZAI& zai) const
{
@@ -155,26 +156,6 @@ bool DecayDataBank::IsDefine(const ZAI& zai) const
//________________________________________________________________________
// Get Decay
//________________________________________________________________________
-/*IsotopicVector DecayDataBank::GetDecay(IsotopicVector isotopicvector, cSecond t)
-{
-DBGL
- IsotopicVector IV;
-
- map<ZAI ,double> isotopicquantity = isotopicvector.GetIsotopicQuantity();
- map<ZAI ,double >::iterator it;
- for( it = isotopicquantity.begin(); it != isotopicquantity.end(); it++)
- {
- if((*it).second > 0)
- {
- IsotopicVector ivtmp = Evolution(it->first, t) * (*it).second ;
- IV += ivtmp;
- }
- }
-
-DBGL
- return IV;
-}
-*/
IsotopicVector DecayDataBank::GetDecay(IsotopicVector isotopicvector, cSecond t)
{
@@ -189,7 +170,7 @@ IsotopicVector DecayDataBank::GetDecay(IsotopicVector isotopicvector, cSecond t)
exit(1);
}
- if(fFastCalculation)
+ if(fFastCalculation) // If using fast calculation simply interpolate between 2 timesteps
{
map<ZAI ,double> isotopicquantity = isotopicvector.GetIsotopicQuantity();
map<ZAI ,double >::iterator it;
@@ -203,7 +184,7 @@ IsotopicVector DecayDataBank::GetDecay(IsotopicVector isotopicvector, cSecond t)
}
}
- else
+ else // If using precise calculation calculate the evolution at each digit
{
int evolutionDecade[17];
cSecond remainingTime = t;
diff --git a/source/branches/BaM_Dev/src/EquivalenceModel.cxx b/source/branches/BaM_Dev/src/EquivalenceModel.cxx
index 6769842e88b33ddc6a364a67429e1a906803d94a..c03c87d843c3170300692cb3155780e88e4b27f6 100644
--- a/source/branches/BaM_Dev/src/EquivalenceModel.cxx
+++ b/source/branches/BaM_Dev/src/EquivalenceModel.cxx
@@ -60,7 +60,7 @@ void EquivalenceModel::ReadLine(string line)
int pos = 0;
string keyword = tlc(StringLine::NextWord(line, pos, ' '));
- map<string, EQMthPtr>::iterator it = fKeyword.find(keyword);
+ map<string, EQM_MthPtr>::iterator it = fKeyword.find(keyword);
if(it != fKeyword.end())
(this->*(it->second))( line );
@@ -79,9 +79,9 @@ void EquivalenceModel::ReadLine(string line)
void EquivalenceModel::LoadKeyword()
{
DBGL
- fKeyword.insert( pair<string, EQMthPtr>( "k_zail", & EquivalenceModel::ReadZAIlimits));
- fKeyword.insert( pair<string, EQMthPtr>( "k_reactor", & EquivalenceModel::ReadType) );
- fKeyword.insert( pair<string, EQMthPtr>( "k_fuel", & EquivalenceModel::ReadType) );
+ fKeyword.insert( pair<string, EQM_MthPtr>( "k_zail", & EquivalenceModel::ReadZAIlimits));
+ fKeyword.insert( pair<string, EQM_MthPtr>( "k_reactor", & EquivalenceModel::ReadType) );
+ fKeyword.insert( pair<string, EQM_MthPtr>( "k_fuel", & EquivalenceModel::ReadType) );
DBGL
}
@@ -298,7 +298,7 @@ vector<double> EquivalenceModel::BuildFuel(double BurnUp, double HMMass, vector<
WeightPuContent = MolarPuContent * MeanMolarPu / MeanMolar;
- fActualFissileContent = MolarPuContent; //fActualFissileContent can be accessed by a derivated EquivalenModel to accelerate GetFissileMolarFraction function (exemple in EQM_MLP_Kinf)
+ fActualFissileContent = MolarPuContent; //fActualFissileContent can be accessed by a derivated EquivalenModel to accelerate GetFissileMolarFraction function (exemple in EQM_PWR_MLP_Kinf)
PuMassNeeded = WeightPuContent * HMMass ;
DBGV( "MolarPuContent " << MolarPuContent << " DeltaM " << PuMassNeeded - AvailablePuMass << " g" );
@@ -307,9 +307,9 @@ vector<double> EquivalenceModel::BuildFuel(double BurnUp, double HMMass, vector<
}while( fabs( PuMassNeeded - AvailablePuMass )/HMMass > fRelativMassPrecision );
- (*this).isIVInDomain(fissil);
+ (*this).isIVInDomain(Fissile);
- DBGV( "Weight percent fissil : " << PuMassNeeded/HMMass );
+ DBGV( "Weight percent fissile : " << PuMassNeeded/HMMass );
DBGV( "Lambda vector : " );
for(int i = 0; i < (int)FissilArray.size() + (int)FertilArray.size(); i++ )
diff --git a/source/branches/BaM_Dev/src/Makefile b/source/branches/BaM_Dev/src/Makefile
index 2669a75432dc0787f78353ab8429287289be64e1..068e8e16f7fbf415a18ad6958858e172ca797493 100755
--- a/source/branches/BaM_Dev/src/Makefile
+++ b/source/branches/BaM_Dev/src/Makefile
@@ -40,9 +40,9 @@ OBJS = CLASSLogger.o \
CLASSFuelPlan.o\
Scenario.o
-OBJMODEL = $(EQM)/EQM_MLP_PWR_MOX.o $(EQM)/EQM_QUAD_PWR_MOX.o $(EQM)/EQM_POL_PWR_UO2.o\
- $(EQM)/EQM_LIN_PWR_MOX.o $(EQM)/EQM_BakerRoss_FBR_MOX.o $(EQM)/EQM_MLP_Kinf.o\
- $(EQM)/EQM_MLP_Keff_FBR.o\
+OBJMODEL = $(EQM)/EQM_PWR_MLP_MOX.o $(EQM)/EQM_PWR_QUAD_MOX.o $(EQM)/EQM_PWR_POL_UO2.o\
+ $(EQM)/EQM_PWR_LIN_MOX.o $(EQM)/EQM_FBR_BakerRoss_MOX.o $(EQM)/EQM_PWR_MLP_Kinf.o\
+ $(EQM)/EQM_FBR_MLP_Keff.o $(EQM)/EQM_FBR_MLP_Keff_BOUND.o\
$(XSM)/XSM_MLP.o $(XSM)/XSM_CLOSEST.o \
$(IM)/IM_RK4.o $(IM)/IM_Matrix.o
diff --git a/source/branches/BaM_Dev/src/XSModel.cxx b/source/branches/BaM_Dev/src/XSModel.cxx
index 6231822c86c92c2a0fafdbeb7730e3d74aa033ab..dd601be77d42373da0a009478cd60f9e339f7d6e 100644
--- a/source/branches/BaM_Dev/src/XSModel.cxx
+++ b/source/branches/BaM_Dev/src/XSModel.cxx
@@ -65,7 +65,7 @@ void XSModel::ReadLine(string line)
int pos = 0;
string keyword = tlc(StringLine::NextWord(line, pos, ' '));
- map<string, MthPtr>::iterator it = fKeyword.find(keyword);
+ map<string, XSM_MthPtr>::iterator it = fKeyword.find(keyword);
if(it != fKeyword.end())
(this->*(it->second))( line );
@@ -84,11 +84,11 @@ void XSModel::ReadLine(string line)
void XSModel::LoadKeyword()
{
DBGL
- fKeyword.insert( pair<string, MthPtr>( "k_zail", & XSModel::ReadZAIlimits));
- fKeyword.insert( pair<string, MthPtr>( "k_reactor", & XSModel::ReadType) );
- fKeyword.insert( pair<string, MthPtr>( "k_fuel", & XSModel::ReadType) );
- fKeyword.insert( pair<string, MthPtr>( "k_mass", & XSModel::ReadRParam) );
- fKeyword.insert( pair<string, MthPtr>( "k_power", & XSModel::ReadRParam) );
+ fKeyword.insert( pair<string, XSM_MthPtr>( "k_zail", & XSModel::ReadZAIlimits));
+ fKeyword.insert( pair<string, XSM_MthPtr>( "k_reactor", & XSModel::ReadType) );
+ fKeyword.insert( pair<string, XSM_MthPtr>( "k_fuel", & XSModel::ReadType) );
+ fKeyword.insert( pair<string, XSM_MthPtr>( "k_mass", & XSModel::ReadRParam) );
+ fKeyword.insert( pair<string, XSM_MthPtr>( "k_power", & XSModel::ReadRParam) );
DBGL
}