English Français

Documentation / User's manual in C++ : PDF version

XIV.5. Macros Sensitivity

XIV.5. Macros Sensitivity

XIV.5.1. Macro "sensitivityBrutForceMethodFlowrate.C"

XIV.5.1.1. Objective

The objective of this macro is to perform a sensitivity analysis with brute force method on a set of eight parameters used in the flowrate model described in Section IV.1.2.1. Sensitivity indexes are computed dividing conditional variance by the standard deviation of the output variable.

Warning

This macro is purely illustrative. It is not meant to be used for proper results with a real code / function as it needs a large number of computation to only get the first order index. Its main appeal is to be nicely illustrative: it shows plainly the definition of the conditional expectation and also its variance used to defined the first order sobol indices.

XIV.5.1.2. Macro Uranie

void drawBarWithTuple(TTree *tt, TString sx, TString sy, TString stitle)
{
  
  TLeaf *lx = tt->GetLeaf(sx);
  TLeaf *ly = tt->GetLeaf(sy);
  
  TH1F *hDiv = new TH1F("hDivdrawBarWithTuple",stitle,3,0,3);
  hDiv->SetCanExtend(TH1::kXaxis); //SetBit(TH1::kCanRebin);
  hDiv->SetStats(0);
  
  if ( hDiv ) {
    hDiv->SetBarWidth(0.45);
    hDiv->SetBarOffset(0.1);
    hDiv->SetMarkerColor(2);
    hDiv->SetMarkerSize(2);
    hDiv->SetFillColor(49);
    hDiv->SetTitle(stitle);
    for (Int_t i = 0; i < tt->GetEntries(); i++) {
      tt->GetEntry(i);
      TString title = *((string*)lx->GetValuePointer());
      hDiv->Fill(title, ly->GetValue());
   }
    hDiv->LabelsDeflate();
    hDiv->LabelsOption(">u");
    hDiv->SetMinimum(0.0);
    hDiv->SetMaximum(1.0);
    gStyle->SetPaintTextFormat("5.2f");
    hDiv->Draw("bar2, text45");
  }
}

void sensitivityBrutForceMethodFlowrate(Int_t nCond = 50, Int_t nbins = 10)
{
  
  // Create a TDataServer
  TDataServer * tds = new TDataServer();
  
  cout << endl << " ******************************************************" << endl;
  cout << " ** sensitivityBrutForceMethodFlowrate nbins[" << nbins << "] nCond[" << nCond << "]" << endl;
  cout << " **" << endl;
  
  // Add the eight attributes of the study with uniform law
  tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
  tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
  tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
  tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
  tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
  tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
  tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
  tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
     
  Int_t nvar = tds->getNAttributes();
  cout << " ** nX[" << nvar << "]" << endl;

  Int_t nS = nbins*nvar*nCond;
  cout << " ** nS[" << nS << "]" << endl;
     
  // TSampling *sam = new TSampling(tds, "lhs", nS);
  TQMC * sam = new TQMC(tds, "halton", nS);
  sam->generateSample();
    
  // Load the function
  gROOT->LoadMacro("UserFunctions.C");

  // Create a TLauncherFunction from a TDataServer and an analytical function
  // Rename the outpout attribute "ymod"
  TLauncherFunction * tlf = new TLauncherFunction(tds, "flowrateModel","","ymod");
  // Evaluate the function on all the design of experiments
  tlf->setDrawProgressBar(kFALSE);
  tlf->run();
   
  TCanvas *Canvas = new TCanvas("c1", "Graph for the Macro modeler",5,64,1270,667);
  TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
  pad->Divide(2,2);
  pad->cd(1);
  tds->computeStatistic("ymod");
  tds->draw("ymod");
  Double_t dstdy = tds->getAttribute("ymod")->getStd();
  Double_t svary = dstdy * dstdy; 
  cout << " ** ymod : std[" << dstdy << "] vary[" << svary  << "]" << endl;

  tds->getAttribute("ymod")->setOutput();  
  
  gStyle->SetOptStat(1);
  
  // Tempory TTree for Histogram visualisation
  Double_t valSobolCrt;
  string   sName;
  TTree *tt = new TTree("sobolforcebrut","MonteCarlo brute force sobol sensitivity ");
  tt->Branch("Var","string",&sName);
  tt->Branch("Value",&valSobolCrt,"Value/D");
  tt->SetMarkerColor(kRed);
  tt->SetMarkerStyle(7);
  tt->SetMarkerSize(1.75);
  
  TCanvas *c = new TCanvas();
  c->Divide(2);
  c->cd(1);
  for(Int_t ivar=0; ivar<nvar; ivar++) {
    cout << " *****************************" << endl << " *** " <<  tds->getAttribute(ivar)->GetName() << endl;
    
    const char * svar = tds->getAttribute(ivar)->GetName();
    
    if(ivar==0)
     pad->cd(2);
    else
     c->cd(1);

    tds->drawProfile(Form("ymod:%s", svar),"",Form("nclass=%d", nbins));
    TProfile *hprofs = (TProfile*)gPad->GetPrimitive(Form("Profile ymod:%s (Bin = %d )", svar, nbins+2));
    
    TNtupleD * ntd = new TNtupleD("dd", "sjsjs", "i:x:m");
    ntd->SetMarkerColor(kBlue);
    ntd->SetMarkerStyle(8);
    //    ntd->SetMarkerSize(1.25);
    Int_t nnbins = hprofs->GetNbinsX();
    for(Int_t i=1; i <= nnbins; i++)
      ntd->Fill(i-1, hprofs->GetBinCenter(i), hprofs->GetBinContent(i));
    
     tds->draw(Form("ymod:%s", svar));
     ntd->Draw("m:x", "","same");
    
    if(ivar==0)
      pad->cd(3);
    else
      c->cd(2);

    ntd->Draw("m");
    TH1F *htemp = (TH1F*)gPad->GetPrimitive("htemp");
    
    Double_t dvarcond = htemp->GetRMS();

    // Tempory TTree for histogram
    sName=string(svar);
    valSobolCrt = dvarcond*dvarcond /svary;
    tt->Fill();
    cout << " *** S1[ " << svar <<"] Cond. Var.[" << dvarcond*dvarcond << "] -- [" << valSobolCrt <<"]" << endl;

    c->Modified(); c->Update(); c->SaveAs(Form("SAFlowRateVersus%s.png", svar));
    
    delete ntd;
  }
  pad->cd(4);
  drawBarWithTuple(tt, "Var", "Value", "Sensitivity Indexes : ymod  [ Brute-Force Method ]");

      
} 

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval:

TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

A design-of-experiments is built with a "Halton" method ( = 4000):

TQMC * sam = new TQMC(tds, "halton", nS);
sam->generateSample();

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros):

gROOT->LoadMacro("UserFunctions.C");

The flowrateModel model is applied on previous variables:

TLauncherFunction * tlf = new TLauncherFunction(tds, "flowrateModel","","ymod");
tlf->run();

Characteristic values for the output attribute are computed:

tds->computeStatistic("ymod");

Sensitivity indexes are computed in the for loop. Average value of output variable is computed on nbins+2=12 points for each input variable:

c->cd(1);
...    
Int_t nnbins = hprofs->GetNbinsX();
for(Int_t i=1; i <= nnbins; i++)
ntd->Fill(i-1, hprofs->GetBinCenter(i), hprofs->GetBinContent(i));

The RMS value is obtained from the graphic of ymod versus the considered output variable and the sensitivity index is computed dividing the conditional variance value by the standard deviation of the output variable ymod.

c->cd(2);
ntd->Draw("m");
TH1F *htemp = (TH1F*)gPad->GetPrimitive("htemp");
Double_t dvarcond = htemp->GetRMS();
valSobolCrt = dvarcond*dvarcond /svary;

XIV.5.1.3. Graph

Figure XIV.44. Graph of the macro "sensitivityBrutForceMethodFlowrate.C"

Graph of the macro "sensitivityBrutForceMethodFlowrate.C"

XIV.5.1.4. Console

Processing sensitivityBrutForceMethodFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024


 ******************************************************
 ** sensitivityBrutForceMethodFlowrate nbins[10] nCond[50]
 **
 ** nX[8]
 ** nS[4000]
 ** ymod : std[45.6059] vary[2079.9]
 *****************************
 *** rw
 *** S1[ rw] Cond. Var.[1763.28] -- [0.847774]
Info in <TCanvas::Print>: png file SAFlowRateVersusrw.png has been created
 *****************************
 *** r
 *** S1[ r] Cond. Var.[0.0624988] -- [3.00489e-05]
Info in <TCanvas::Print>: png file SAFlowRateVersusr.png has been created
 *****************************
 *** tu
 *** S1[ tu] Cond. Var.[0.0886501] -- [4.26223e-05]
Info in <TCanvas::Print>: png file SAFlowRateVersustu.png has been created
 *****************************
 *** tl
 *** S1[ tl] Cond. Var.[0.0909604] -- [4.37331e-05]
Info in <TCanvas::Print>: png file SAFlowRateVersustl.png has been created
 *****************************
 *** hu
 *** S1[ hu] Cond. Var.[88.368] -- [0.0424867]
Info in <TCanvas::Print>: png file SAFlowRateVersushu.png has been created
 *****************************
 *** hl
 *** S1[ hl] Cond. Var.[88.2039] -- [0.0424078]
Info in <TCanvas::Print>: png file SAFlowRateVersushl.png has been created
 *****************************
 *** l
 *** S1[ l] Cond. Var.[84.9543] -- [0.0408454]
Info in <TCanvas::Print>: png file SAFlowRateVersusl.png has been created
 *****************************
 *** kw
 *** S1[ kw] Cond. Var.[20.8848] -- [0.0100413]
Info in <TCanvas::Print>: png file SAFlowRateVersuskw.png has been created

XIV.5.2. Macro "sensitivityFiniteDifferencesFunctionFlowrate.C"

XIV.5.2.1. Objective

The objective of this macro is to compute the finite differences indexes on a function.

XIV.5.2.2. Macro Uranie

{
  // loading the flowrateModel function  
  gROOT->LoadMacro("UserFunctions.C");
    
  // Define the DataServer  and add the attributes (stochastic variables here)
  TDataServer *tds = new TDataServer("tdsflowrate", "DataBase flowrate");
  tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
  tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
  tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
  tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
  tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
  tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
  tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
  tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
  

  tds->getAttribute("rw")->setDefaultValue(0.075);
  tds->getAttribute("r")->setDefaultValue(25000.0);
  tds->getAttribute("tu")->setDefaultValue(90000.0);
  tds->getAttribute("tl")->setDefaultValue(90.0);
  tds->getAttribute("hu")->setDefaultValue(1050.0);
  tds->getAttribute("hl")->setDefaultValue(760.0);
  tds->getAttribute("l")->setDefaultValue(1400.0);
  tds->getAttribute("kw")->setDefaultValue(10500.0);
  
 // Create a TFiniteDifferences object 	    
 TFiniteDifferences * tfindef = new TFiniteDifferences(tds,"flowrateModel", "rw:r:tu:tl:hu:hl:l:kw", "y", "steps=1%");
 tfindef->setDrawProgressBar(kFALSE);
 tfindef->computeIndexes();
 TMatrixD matRes = tfindef->getSensitivityMatrix();
 matRes.Print();
    
  
}
  

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval:

TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

Each parameter gets a default value:

tds->getAttribute("rw")->setDefaultValue(0.075);
tds->getAttribute("r")->setDefaultValue(25000.0);
tds->getAttribute("tu")->setDefaultValue(90000.0);
tds->getAttribute("tl")->setDefaultValue(90.0);
tds->getAttribute("hu")->setDefaultValue(1050.0);
tds->getAttribute("hl")->setDefaultValue(760.0);
tds->getAttribute("l")->setDefaultValue(1400.0);
tds->getAttribute("kw")->setDefaultValue(10500.0);

To instantiate the TFiniteDifferences object, one uses the TDataServer, the name of the function, the name of the output of the function, the names of the input variables separated by ":" and the option to specify the sampling:

TFiniteDifferences * tfindef = new TFiniteDifferences(tds, "flowrateModel", "rw:r:tu:tl:hu:hl:l:kw","y", "steps=1%");

Computation of sensitivity indexes:

tfindef->computeIndexes();

XIV.5.2.3. Console

Processing sensitivityFiniteDifferencesFunctionFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024


1x8 matrix is as follows

     |      0    |      1    |      2    |      3    |      4    |
----------------------------------------------------------------------
   0 |       1019  -3.586e-07   1.265e-09    0.001265      0.1321 


     |      5    |      6    |      7    |
----------------------------------------------------------------------
   0 |    -0.1321    -0.02729    0.003639 

XIV.5.3. Macro "sensitivityDataBaseFlowrate.C"

XIV.5.3.1. Objective

The objective of this macro is to perform a SRC regression on data stored in a TDataServer. Data are loaded in the TDataServer from an ASCII data file flowrateUniformDesign.dat:

#NAME: flowrateborehole
#TITLE: Uniform design of flow rate borehole problem proposed by Ho and Xu(2000)
#COLUMN_NAMES: rw| r| tu| tl| hu| hl| l| kw | ystar
#COLUMN_TITLES: r_{#omega}| r | T_{u} | T_{l} | H_{u} | H_{l} | L | K_{#omega} | y^{*}
#COLUMN_UNITS: m | m | m^{2}/yr | m^{2}/yr | m | m | m | m/yr | m^{3}/yr

0.0500 33366.67  63070.0 116.00 1110.00 768.57 1200.0 11732.14  26.18
0.0500   100.00  80580.0  80.73 1092.86 802.86 1600.0 10167.86  14.46
0.0567   100.00  98090.0  80.73 1058.57 717.14 1680.0 11106.43  22.75
0.0567 33366.67  98090.0  98.37 1110.00 734.29 1280.0 10480.71  30.98
0.0633   100.00 115600.0  80.73 1075.71 751.43 1600.0 11106.43  28.33
0.0633 16733.33  80580.0  80.73 1058.57 785.71 1680.0 12045.00  24.60
0.0700 33366.67  63070.0  98.37 1092.86 768.57 1200.0 11732.14  48.65
0.0700 16733.33 115600.0 116.00  990.00 700.00 1360.0 10793.57  35.36
0.0767   100.0  115600.0  80.73 1075.71 751.43 1520.0 10793.57  42.44
0.0767 16733.33  80580.0  80.73 1075.71 802.86 1120.0  9855.00  44.16
0.0833 50000.00  98090.0  63.10 1041.43 717.14 1600.0 10793.57  47.49
0.0833 50000.00 115600.0  63.10 1007.14 768.57 1440.0 11419.29  41.04
0.0900 16733.33  63070.0 116.00 1075.71 751.43 1120.0 11419.29  83.77
0.0900 33366.67 115600.0 116.00 1007.14 717.14 1360.0 11106.43  60.05
0.0967 50000.00  80580.0  63.10 1024.29 820.00 1360.0  9855.00  43.15
0.0967 16733.33  80580.0  98.37 1058.57 700.00 1120.0 10480.71  97.98
0.1033 50000.00  80580.0  63.10 1024.29 700.00 1520.0 10480.71  74.44
0.1033 16733.33  80580.0  98.37 1058.57 820.00 1120.0 10167.86  72.23
0.1100 50000.00  98090.0  63.10 1024.29 717.14 1520.0 10793.57  82.18
0.1100   100.00  63070.0  98.37 1041.43 802.86 1600.0 12045.00  68.06
0.1167 33366.67  63070.0 116.00  990.00 785.71 1280.0 12045.00  81.63
0.1167   100.00  98090.0  98.37 1092.86 802.86 1680.0  9855.00  72.5
0.1233 16733.33 115600.0  80.73 1092.86 734.29 1200.0 11419.29 161.35
0.1233 16733.33  63070.0  63.10 1041.43 785.71 1680.0 12045.00  86.73
0.1300 33366.67  80580.0 116.00 1110.00 768.57 1280.0 11732.14 164.78
0.1300   100.00  98090.0  98.37 1110.00 820.00 1280.0 10167.86 121.76
0.1367 50000.00  98090.0  63.10 1007.14 820.00 1440.0 10167.86  76.51
0.1367 33366.67  98090.0 116.00 1024.29 700.00 1200.0 10480.71 164.75
0.1433 50000.00  63070.0 116.00  990.00 785.71 1440.0  9855.00  89.54
0.1433 50000.00 115600.0  63.10 1007.14 734.29 1440.0 11732.14 141.09
0.1500 33366.67  63070.0  98.37  990.00 751.43 1360.0 11419.29 139.94 
0.1500   100.00 115600.0  80.73 1041.43 734.29 1520.0 11106.43 157.59

XIV.5.3.2. Macro Uranie

{
  // Create a TDataServer
  TDataServer * tds = new TDataServer();
  // Load a database in an ASCII file
  tds->fileDataRead("flowrateUniformDesign.dat");
  
  // Graph
  TCanvas  *Canvas = new TCanvas("c2", "Graph for the Macro",5,64,1270,667);
  // Visualisation
  tds->Draw("ystar:rw");
  
  // Sensitivity analysis
  TRegression *treg = new TRegression(tds, "rw:r:tu:tl:hu:hl:l:kw", "ystar", "src");
  treg->computeIndexes();
    
  treg->drawIndexes("Flowrate", "", "hist,first");
  //treg->getResultTuple()->Scan();
  
  // Graph
  TCanvas *c = (TCanvas *)(gROOT->FindObject("__sensitivitycan__0"));
  TCanvas  *can = new TCanvas("c1", "Graph for the Macro sensitivityDataBaseFlowrate",5,64,1270,667);
  TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
  pad->Divide(2);
  pad->cd(1);
  Canvas->DrawClonePad();
  pad->cd(2);
  c->DrawClonePad();
  
}
  

The TDataServer is filled with the data file flowrateUniformDesign.dat through the fileDataRead method:

tds->fileDataRead("flowrateUniformDesign.dat");

The regression is performed on all the variables with a SRC method and sensitivity indexes are computed:

TRegression *treg = new TRegression(tds, "rw:r:tu:tl:hu:hl:l:kw", "ystar", "src");
treg->computeIndexes();

XIV.5.3.3. Graph

Figure XIV.45. Graph of the macro "sensitivityDataBaseFlowrate.C"

Graph of the macro "sensitivityDataBaseFlowrate.C"

XIV.5.4. Macro "sensitivityFASTFunctionFlowrate.C"

XIV.5.4.1. Objective

The objective of this macro is to perform a Fast sensitivity analysis on a set of eight parameters used in the flowrateModel model described in Section IV.1.2.1.

XIV.5.4.2. Macro Uranie

void sensitivityFASTFunctionFlowrate(){
  
  gROOT->LoadMacro("UserFunctions.C");
      
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
  tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
  tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
  tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
  tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
  tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
  tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
  tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
  tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
    
  // \param Size of a sampling.
  Int_t nS = 4000;
  // Graph
  TFast * tfast = new TFast(tds, "flowrateModel", nS);
  tfast->setDrawProgressBar(kFALSE);
  tfast->computeIndexes("graph");

  tfast->getResultTuple()->Scan("Out:Inp:Order:Method:Value","Algo==\"--first--\"");
    
}

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval:

TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

To instantiate the TFast object, one uses the TDataServer, the name of the function and the number of samplings needed to perform sensitivity analysis (here nS=500):

TFast * tfast = new TFast(tds, "flowrateModel", nS);

Computation of sensitivity indexes:

tfast->computeIndexes();

XIV.5.4.3. Graph

Figure XIV.46. Graph of the macro "sensitivityFASTFunctionFlowrate.C"

Graph of the macro "sensitivityFASTFunctionFlowrate.C"

XIV.5.4.4. Console

Processing sensitivityFASTFunctionFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[8099]
 <URANIE::WARNING> TDataServer::getTuple Error : There is no tree!
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[8099]
 <URANIE::WARNING> TDataServer::getTuple Error : There is no tree!
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::INFO> 
 <URANIE::INFO> *** URANIE INFORMATION ***
 <URANIE::INFO> *** File[${SOURCEDIR}/meTIER/sampler/souRCE/TSpaceFilling.cxx] Line[167]
 <URANIE::INFO> TSamplerStochastic::init: the TDS [tdsflowreate] contains data: we need to empty it ! 
 <URANIE::INFO> *** END of URANIE INFORMATION ***
 <URANIE::INFO> 
************************************************************************
*    Row   *       Out *       Inp *     Order *    Method *     Value *
************************************************************************
*        0 * flowrateM *        rw *     First *      FAST * 0.8278187 *
*        2 * flowrateM *         r *     First *      FAST * 8.924e-07 *
*        4 * flowrateM *        tu *     First *      FAST * 2.308e-06 *
*        6 * flowrateM *        tl *     First *      FAST * 3.204e-05 *
*        8 * flowrateM *        hu *     First *      FAST * 0.0414390 *
*       10 * flowrateM *        hl *     First *      FAST * 0.0414046 *
*       12 * flowrateM *         l *     First *      FAST * 0.0392873 *
*       14 * flowrateM *        kw *     First *      FAST * 0.0094983 *
************************************************************************
==> 8 selected entries

XIV.5.5. Macro "sensitivityRBDFunctionFlowrate.C"

XIV.5.5.1. Objective

The objective of this macro is to perform a RBD sensitivity analysis on a set of eight parameters used in the flowrateModel model described in Section IV.1.2.1.

XIV.5.5.2. Macro Uranie

void sensitivityRBDFunctionFlowrate(){
  
  gROOT->LoadMacro("UserFunctions.C");
        
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowrate", "DataBase flowrate");
  tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
  tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
  tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
  tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
  tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
  tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
  tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
  tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
    
  // \param Size of a sampling.
  Int_t nS = 4000;
  // Graph
  TRBD * trbd = new TRBD(tds, "flowrateModel", nS); 
  trbd->setDrawProgressBar(kFALSE);
  trbd->computeIndexes("graph");

  trbd->getResultTuple()->Scan("Out:Inp:Order:Method:Value","Algo==\"--first--\"");
    
}

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval

TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

To instantiate the TRBD object, one uses the TDataServer, the name of the function and the number of samplings needed to perform sensitivity analysis (here =4000):

TRBD * trbd = new TRBD(tds, "flowrateModel", nS);

Computation of sensitivity indexes:

trbd->computeIndexes();

XIV.5.5.3. Graph

Figure XIV.47. Graph of the macro "sensitivityRBDFunctionFlowrate.C"

Graph of the macro "sensitivityRBDFunctionFlowrate.C"

XIV.5.5.4. Console

Processing sensitivityRBDFunctionFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[8099]
 <URANIE::WARNING> TDataServer::getTuple Error : There is no tree!
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[8099]
 <URANIE::WARNING> TDataServer::getTuple Error : There is no tree!
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::INFO> 
 <URANIE::INFO> *** URANIE INFORMATION ***
 <URANIE::INFO> *** File[${SOURCEDIR}/meTIER/sampler/souRCE/TSpaceFilling.cxx] Line[167]
 <URANIE::INFO> TSamplerStochastic::init: the TDS [tdsflowrate] contains data: we need to empty it ! 
 <URANIE::INFO> *** END of URANIE INFORMATION ***
 <URANIE::INFO> 
************************************************************************
*    Row   *       Out *       Inp *     Order *    Method *     Value *
************************************************************************
*        0 * flowrateM *        rw *     First *       RBD * 0.7558010 *
*        2 * flowrateM *         r *     First *       RBD * 0.0026080 *
*        4 * flowrateM *        tu *     First *       RBD * 0.0035324 *
*        6 * flowrateM *        tl *     First *       RBD * 0.0032848 *
*        8 * flowrateM *        hu *     First *       RBD * 0.0408758 *
*       10 * flowrateM *        hl *     First *       RBD * 0.0469345 *
*       12 * flowrateM *         l *     First *       RBD * 0.0347870 *
*       14 * flowrateM *        kw *     First *       RBD * 0.0165843 *
************************************************************************
==> 8 selected entries

XIV.5.6. Macro "sensitivityMorrisFunctionFlowrate.C"

XIV.5.6.1. Objective

The objective of this macro is to perform a Morris sensitivity analysis on a set of eight parameters used in the flowrateModel model described in Section IV.1.2.1.

XIV.5.6.2. Macro Uranie


void sensitivityMorrisFunctionFlowrate(Int_t nk = 5)
{
      
  gROOT->LoadMacro("UserFunctions.C");

  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
  tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
  tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
  tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
  tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
  tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
  tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
  tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
  tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
    
  Int_t nreplique = 3;
  Int_t nlevel = 10;
  TMorris * scmo = new TMorris(tds, "flowrateModel", nreplique, nlevel); 
  scmo->setDrawProgressBar(kFALSE);
  scmo->generateSample();
    
  tds->exportData("_morris_sampling_.dat");
  scmo->computeIndexes();
    
  tds->exportData("_morris_launching_.dat");

  TTree *ntresu = scmo->getMorrisResults();
  ntresu->Scan("*");
     
  // Graph
  TCanvas  *cc = new TCanvas("c1", "Graph for the Macro sensitivityMorrisFunctionFlowrate",5,64,1270,667);
  TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
  pad->Divide(2);
  pad->cd(1);
  scmo->drawSample("", -1,"nonewcanv");
  pad->cd(2);
  scmo->drawIndexes("mustar,nonewcanv");
   
}

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval:

TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

To instantiate the TMorris , one uses the TDataServer, the name of the function, the number of replicas (here nreplique=3), the level parameter (here nlevel=10)

TMorris * scmo = new TMorris(tds, "flowrateModel", nreplique, nlevel);

Creation of the sampling:

scmo->generateSample();

Data are exported in an ASCII file:

tds->exportData("_morris_sampling_.dat");

Computation of sensitivity indexes:

scmo->computeIndexes();

XIV.5.6.3. Graph

Figure XIV.48. Graph of the macro "sensitivityMorrisFunctionFlowrate.C"

Graph of the macro "sensitivityMorrisFunctionFlowrate.C"

XIV.5.6.4. Console

Processing sensitivityMorrisFunctionFlowrate.C...
************************************************************************
*    Row   *     Input *    Output *     mu.mu * mustar.mu * sigma.sig *
************************************************************************
*        0 *        rw * flowrateM * 127.47900 * 127.47900 * 34.521839 *
*        1 *         r * flowrateM * -0.069601 * 0.0696013 * 0.0793689 *
*        2 *        tu * flowrateM * 0.0004201 * 0.0004201 * 0.0004641 *
*        3 *        tl * flowrateM * 0.4659763 * 0.4659763 * 0.3301256 *
*        4 *        hu * flowrateM * 21.192361 * 21.192361 * 8.8498989 *
*        5 *        hl * flowrateM * -32.74887 * 32.748874 * 30.146134 *
*        6 *         l * flowrateM * -23.89328 * 23.893280 * 8.2781934 *
*        7 *        kw * flowrateM * 7.5766167 * 7.5766167 * 2.7457665 *
************************************************************************

XIV.5.7. Macro "sensitivityMorrisFunctionFlowrateRunner.C"

XIV.5.7.1. Objective

The objective of this macro is to perform a Morris sensitivity analysis on a set of eight parameters used in the flowrateModel model described in Section IV.1.2.1, but this time using the Relauncher architecture.

XIV.5.7.2. Macro Uranie


void sensitivityMorrisFunctionFlowrateRunner(Int_t nk = 5)
{
      
  gROOT->LoadMacro("UserFunctions.C");

  // Define the attributes
  TUniformDistribution rw("rw", 0.05, 0.15);
  TUniformDistribution r("r", 100.0, 50000.0);
  TUniformDistribution tu("tu", 63070.0, 115600.0);
  TUniformDistribution tl("tl", 63.1, 116.0);
  TUniformDistribution hu("hu", 990.0, 1110.0);
  TUniformDistribution hl("hl", 700.0, 820.0);
  TUniformDistribution l("l", 1120.0, 1680.0);
  TUniformDistribution kw("kw", 9855.0, 12045.0);

  // Create the evaluator
  TCIntEval code("flowrateModel");
  // Create output attribute
  TAttribute yout("flowrateModel");
  // Provide input/output attributes to the assessor
  code.setInputs(8, &rw, &r, &tu, &tl, &hu, &hl, &l, &kw);
  code.setOutputs(1, &yout);

  TSequentialRun run(&code); // To be replaced to distribute the computation
  run.startSlave();
  if( run.onMaster())
  {
    // Create the dataserver
    TDataServer *tds = new TDataServer("sobol", "foo bar pouet chocolat");
    tds->addAttribute(&rw);
    tds->addAttribute(&r);
    tds->addAttribute(&tu);
    tds->addAttribute(&tl);
    tds->addAttribute(&hu);
    tds->addAttribute(&hl);
    tds->addAttribute(&l);
    tds->addAttribute(&kw);    
    Int_t nreplique = 3;
    Int_t nlevel = 10;
    // Create the Morris object     
    TMorris * scmo = new TMorris(tds, &run, nreplique, nlevel); 
    scmo->setDrawProgressBar(kFALSE);
    scmo->generateSample();
    
    tds->exportData("_morris_sampling_.dat");
    scmo->computeIndexes();
    
    tds->exportData("_morris_launching_.dat");

    TTree *ntresu = scmo->getMorrisResults();
    ntresu->Scan("*");
     
    // Graph
    TCanvas  *cc = new TCanvas("c1", "Graph for the Macro sensitivityMorrisFunctionFlowrateRunner",5,64,1270,667);
    TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
    pad->Divide(2);
    pad->cd(1);
    scmo->drawSample("", -1,"nonewcanv");
    pad->cd(2);
    scmo->drawIndexes("mustar,nonewcanv");
   
  }
}

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval:

// Define the attributes
TUniformDistribution rw("rw", 0.05, 0.15);
TUniformDistribution r("r", 100.0, 50000.0);
TUniformDistribution tu("tu", 63070.0, 115600.0);
TUniformDistribution tl("tl", 63.1, 116.0);
TUniformDistribution hu("hu", 990.0, 1110.0);
TUniformDistribution hl("hl", 700.0, 820.0);
TUniformDistribution l("l", 1120.0, 1680.0);
TUniformDistribution kw("kw", 9855.0, 12045.0);

The interface to the function is then defined, using the Relauncher interface, through a TCIntEval object and a sequential runner:

 // Create the evaluator
TCIntEval code("flowrateModel");
// Create output attribute
TAttribute yout("flowrateModel");
// Provide input/output attributes to the assessor
code.setInputs(8, &rw, &r, &tu, &tl, &hu, &hl, &l, &kw);
code.setOutputs(1, &yout);

TSequentialRun run(&code); // To be replaced to distribute the computation
run.startSlave();

The dataserver object is defined only on the master to avoid useless replication if one wants to run the estimation of the function in parallel (by changing the TSequentialRun by either a TThreadedRun or a TMpiRun). To instantiate the TMorris object, one uses the TDataServer, a pointer to the chosen runner, the number of replicas (here nreplique=3), the level parameter (here nlevel=10)

TMorris * scmo = new TMorris(tds, &run, nreplique, nlevel); 

Creation of the sampling:

scmo->generateSample();

Data are exported in an ASCII file:

tds->exportData("_morris_sampling_.dat");

Computation of sensitivity indexes:

scmo->computeIndexes();

The rest of the code is providing command to get a final plot.

XIV.5.7.3. Graph

Figure XIV.49. Graph of the macro "sensitivityMorrisFunctionFlowrateRunner.C"

Graph of the macro "sensitivityMorrisFunctionFlowrateRunner.C"

XIV.5.7.4. Console

Processing sensitivityMorrisFunctionFlowrateRunner.C...
************************************************************************
*    Row   *     Input *    Output *     mu.mu * mustar.mu * sigma.sig *
************************************************************************
*        0 *        rw * flowrateM * 127.47900 * 127.47900 * 34.521839 *
*        1 *         r * flowrateM * -0.069601 * 0.0696013 * 0.0793689 *
*        2 *        tu * flowrateM * 0.0004201 * 0.0004201 * 0.0004641 *
*        3 *        tl * flowrateM * 0.4659763 * 0.4659763 * 0.3301256 *
*        4 *        hu * flowrateM * 21.192361 * 21.192361 * 8.8498989 *
*        5 *        hl * flowrateM * -32.74887 * 32.748874 * 30.146134 *
*        6 *         l * flowrateM * -23.89328 * 23.893280 * 8.2781934 *
*        7 *        kw * flowrateM * 7.5766167 * 7.5766167 * 2.7457665 *
************************************************************************

XIV.5.8. Macro "sensitivityRegressionFunctionFlowrate.C"

XIV.5.8.1. Objective

The objective of this macro is to perform a regression with "SRC" method on a database generated with a function using sampling of parameters obeying uniform laws with 4000 patterns. flowrateModel is a function defined in Section IV.1.2.1 and "loaded" through the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros). Function flowrateModel uses the eight variables defined in Section IV.1.2.1 and set in the main macro.

XIV.5.8.2. Macro Uranie

void sensitivityRegressionFunctionFlowrate(){
   
  gROOT->LoadMacro("UserFunctions.C");
  
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
  tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
  tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
  tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
  tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
  tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
  tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
  tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
  tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
    
  // \param Size of a sampling.
  Int_t nS = 4000;

  TSampling *sampling = new TSampling(tds, "lhs", nS);
  sampling->generateSample();	
    

  TLauncherFunction * tlf = new TLauncherFunction(tds, "flowrateModel");
  tlf->setDrawProgressBar(kFALSE);
  tlf->run();
    
  
  TRegression * treg = new TRegression(tds, "rw:r:tu:tl:hu:hl:l:kw","flowrateModel", "SRC");
  treg->computeIndexes();
  treg->getResultTuple()->SetScanField(60);
  
  treg->getResultTuple()->Scan("Out:Inp:Method:Algo:Value:CILower:CIUpper","Order==\"First\"");
    

  TCanvas  *can = new TCanvas("c1", "Graph for the Macro sensitivityRegressionFunctionFlowrate",5,64,1270,667);
  treg->drawIndexes("Flowrate", "", "hist,first,nonewcanv");  
   
}

Each attribute is related to a TAttribute obeying uniform laws on specific intervals:

tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

The sampling is generated on 4000 patterns with a LHS method:

TSampling *sampling = new TSampling(tds, "lhs", 4000);
sampling->generateSample();

Function flowrateModel is set to perform calculation on the sampling:

TLauncherFunction * tlf = new TLauncherFunction(tds, "flowrateModel");
tlf->run();

The regression is performed over all variables:

TRegression * treg = new TRegression(tds, "rw:r:tu:tl:hu:hl:l:kw","flowrateModel", "SRRC");
treg->computeIndexes();

Sensitivity indexes are then displayed through an histogram and a pie graph:

TCanvas *cc = new TCanvas("canhist", "histgramme");
treg->drawIndexes("Flowrate", "", "nonewcanv,hist,first");
TCanvas *ccc = new TCanvas("canpie", "TPie");
treg->drawIndexes("Flowrate", "", "nonewcanv,pie,first");

XIV.5.8.3. Graph

Figure XIV.50. Graph of the macro "sensitivityRegressionFunctionFlowrate.C"

Graph of the macro "sensitivityRegressionFunctionFlowrate.C"

XIV.5.8.4. Console

Processing sensitivityRegressionFunctionFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

*************************************************************************************
*    Row   *    Out *      Inp * Metho *      Algo *    Value *  CILower *  CIUpper *
*************************************************************************************
*        0 * flowra *       rw * SRC^2 * --first-- * 0.820265 *       -1 *       -1 *
*        2 * flowra *       rw * SRC^2 * --rho^2-- *  0.81668 * 0.805846 * 0.826888 *
*        4 * flowra *        r * SRC^2 * --first-- * 5.97e-06 *       -1 *       -1 *
*        6 * flowra *        r * SRC^2 * --rho^2-- * 1.92e-06 * 2.65e-07 * 0.001339 *
*        8 * flowra *       tu * SRC^2 * --first-- * 8.64e-06 *       -1 *       -1 *
*       10 * flowra *       tu * SRC^2 * --rho^2-- * 4.03e-06 * 3.14e-07 * 0.001306 *
*       12 * flowra *       tl * SRC^2 * --first-- * 5.73e-05 *       -1 *       -1 *
*       14 * flowra *       tl * SRC^2 * --rho^2-- * 0.000209 * 7.34e-07 * 0.002085 *
*       16 * flowra *       hu * SRC^2 * --first-- * 0.039645 *       -1 *       -1 *
*       18 * flowra *       hu * SRC^2 * --rho^2-- * 0.037119 * 0.026221 * 0.049000 *
*       20 * flowra *       hl * SRC^2 * --first-- * 0.040597 *       -1 *       -1 *
*       22 * flowra *       hl * SRC^2 * --rho^2-- * 0.039708 * 0.028688 * 0.052470 *
*       24 * flowra *        l * SRC^2 * --first-- * 0.040895 *       -1 *       -1 *
*       26 * flowra *        l * SRC^2 * --rho^2-- * 0.041241 * 0.029896 * 0.054454 *
*       28 * flowra *       kw * SRC^2 * --first-- * 0.009174 *       -1 *       -1 *
*       30 * flowra *       kw * SRC^2 * --rho^2-- * 0.009090 * 0.004191 * 0.015767 *
*       32 * flowra *  __sum__ * SRC^2 * --first-- *  0.95065 *       -1 *       -1 *
*       34 * flowra *   __R2__ * SRC^2 * --first-- * 0.947296 *       -1 *       -1 *
*       36 * flowra *  __R2A__ * SRC^2 * --first-- *  0.94719 *       -1 *       -1 *
*************************************************************************************
==> 19 selected entries

XIV.5.9. Macro "sensitivitySobolFunctionFlowrate.C"

XIV.5.9.1. Objective

The objective of this macro is to perform Sobol sensitivity analysis on a set of eight parameters used in the flowrateModel model described in Section IV.1.2.1.

XIV.5.9.2. Macro Uranie

{

  gROOT->LoadMacro("UserFunctions.C");
   
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
  tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
  tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
  tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
  tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
  tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
  tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
  tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
  tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
  
  Int_t ns = 100000;
  TSobol * tsobol = new TSobol(tds, "flowrateModel", ns, "rw:r:tu:tl:hu:hl:l:kw", "flowrateModel", "pouet"); 
  tsobol->setDrawProgressBar(kFALSE);
  tsobol->computeIndexes();

  tsobol->getResultTuple()->Scan("*","Algo==\"--first--\" || Algo==\"--total--\"");
      
  TCanvas *cc = new TCanvas("c1", "histgramme",5,64,1270,667);
  TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
  pad->Divide(2,1);
  pad->cd(1);
  tsobol->drawIndexes("Flowrate", "", "nonewcanv,hist,all");
    
  pad->cd(2);
  tsobol->drawIndexes("Flowrate", "", "nonewcanv,pie,first");
    
  gSystem->Rename("_sobol_launching_.dat","ref_sobol_launching_.dat");
  tds->exportData("_onlyMandN_sobol_launching_.dat","rw:r:tu:tl:hu:hl:l:kw:flowrateModel","sobol__n__iter__tdsflowreate < 100");
}

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval:

TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

To instantiate the TSobol, one uses the TDataServer, the name of the function and the number of samplings needed to perform sensitivity analysis (here ns=600):

TSobol * tsobol = new TSobol(tds, "flowrateModel", ns, "rw:r:tu:tl:hu:hl:l:kw", "flowrateModel", "pouet");

Computation of the sensitivity indexes:

tsobol->computeIndexes();

The automatic backup of data (the file _sobol_launching_.dat) is renamed so that it can be used in other macros (see Section XIV.5.13 and Section XIV.5.15) while the tds contains is exported (only the and matrices content) to be also used in another macro (Section XIV.5.14) :

gSystem->Rename("_sobol_launching_.dat","ref_sobol_launching_.dat");
tds->exportData("_onlyMandN_sobol_launching_.dat","rw:r:tu:tl:hu:hl:l:kw:flowrateModel","sobol__n__iter__tdsflowreate < 100");

XIV.5.9.3. Graph

Figure XIV.51. Graph of the macro "sensitivitySobolFunctionFlowrate.C"

Graph of the macro "sensitivitySobolFunctionFlowrate.C"

XIV.5.9.4. Console

Processing sensitivitySobolFunctionFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[8099]
 <URANIE::WARNING> TDataServer::getTuple Error : There is no tree!
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::INFO> 
 <URANIE::INFO> *** URANIE INFORMATION ***
 <URANIE::INFO> *** File[${SOURCEDIR}/meTIER/sampler/souRCE/TSamplerStochastic.cxx] Line[66]
 <URANIE::INFO> TSamplerStochastic::init: the TDS [tdsflowreate] contains data: we need to empty it ! 
 <URANIE::INFO> *** END of URANIE INFORMATION ***
 <URANIE::INFO> 
 ** Case of Output atty [flowrateModel]  nSimPerIndex 10000
 ** Input att [rw] First [0.830033] Total Order[0.865762]
 ** Input att [r] First [0] Total Order[0.000102212]
 ** Input att [tu] First [0] Total Order[0.0001]
 ** Input att [tl] First [0] Total Order[0.000110756]
 ** Input att [hu] First [0.0417298] Total Order[0.0554922]
 ** Input att [hl] First [0.0367345] Total Order[0.0526188]
 ** Input att [l] First [0.0384214] Total Order[0.0535728]
 ** Input att [kw] First [0.00669831] Total Order[0.0132316]
************************************************************************************************************
*    Row   *   Out.Out *   Inp.Inp * Order.Ord * Method.Me * Algo.Algo * Value.Val * CILower.C * CIUpper.C *
************************************************************************************************************
*        0 * flowrateM *        rw *     First *     Sobol * --first-- * 0.8300331 * 0.8238356 * 0.8360321 *
*        4 * flowrateM *        rw *     Total *     Sobol * --total-- * 0.8657619 * 0.8465652 * 0.8850599 *
*        8 * flowrateM *         r *     First *     Sobol * --first-- *         0 *         0 * 0.0196004 *
*       12 * flowrateM *         r *     Total *     Sobol * --total-- * 0.0001022 * 9.828e-05 * 0.0001062 *
*       16 * flowrateM *        tu *     First *     Sobol * --first-- *         0 *         0 * 0.0196004 *
*       20 * flowrateM *        tu *     Total *     Sobol * --total-- * 0.0001000 * 9.615e-05 * 0.0001039 *
*       24 * flowrateM *        tl *     First *     Sobol * --first-- *         0 *         0 * 0.0196004 *
*       28 * flowrateM *        tl *     Total *     Sobol * --total-- * 0.0001107 * 0.0001064 * 0.0001151 *
*       32 * flowrateM *        hu *     First *     Sobol * --first-- * 0.0417297 * 0.0221474 * 0.0612800 *
*       36 * flowrateM *        hu *     Total *     Sobol * --total-- * 0.0554921 * 0.0534156 * 0.0576470 *
*       40 * flowrateM *        hl *     First *     Sobol * --first-- * 0.0367345 * 0.0171464 * 0.0562944 *
*       44 * flowrateM *        hl *     Total *     Sobol * --total-- * 0.0526187 * 0.0506469 * 0.0546652 *
*       48 * flowrateM *         l *     First *     Sobol * --first-- * 0.0384214 * 0.0188352 * 0.0579782 *
*       52 * flowrateM *         l *     Total *     Sobol * --total-- * 0.0535727 * 0.0515661 * 0.0556552 *
*       56 * flowrateM *        kw *     First *     Sobol * --first-- * 0.0066983 *         0 * 0.0262952 *
*       60 * flowrateM *        kw *     Total *     Sobol * --total-- * 0.0132315 * 0.0127261 * 0.0137570 *
*       64 * flowrateM *   __sum__ *     First *     Sobol * --first-- * 0.9536171 *        -1 *        -1 *
*       65 * flowrateM *   __sum__ *     Total *     Sobol * --total-- * 1.0409902 *        -1 *        -1 *
************************************************************************************************************
==> 18 selected entries

XIV.5.10. Macro "sensitivitySobolFunctionFlowrateRunner.C"

XIV.5.10.1. Objective

The objective of this macro is to perform Sobol sensitivity analysis on a set of eight parameters used in the flowrateModel model described in Section IV.1.2.1, but this time using the Relauncher architecture.

XIV.5.10.2. Macro Uranie

{

  gROOT->LoadMacro("UserFunctions.C");
   
  // Define the attributes
  TUniformDistribution rw("rw", 0.05, 0.15);
  TUniformDistribution r("r", 100.0, 50000.0);
  TUniformDistribution tu("tu", 63070.0, 115600.0);
  TUniformDistribution tl("tl", 63.1, 116.0);
  TUniformDistribution hu("hu", 990.0, 1110.0);
  TUniformDistribution hl("hl", 700.0, 820.0);
  TUniformDistribution l("l", 1120.0, 1680.0);
  TUniformDistribution kw("kw", 9855.0, 12045.0);

  // Create the evaluator
  TCIntEval code("flowrateModel");
  // Create output attribute
  TAttribute yout("flowrateModel");
  // Provide input/output attributes to the assessor
  code.setInputs(8, &rw, &r, &tu, &tl, &hu, &hl, &l, &kw);
  code.setOutputs(1, &yout);

  TSequentialRun run(&code); // To be replaced to distribute the computation
  run.startSlave();
  if( run.onMaster())
  {
     // Create the dataserver
     TDataServer *tds = new TDataServer("sobol", "foo bar pouet chocolat");
     tds->addAttribute(&rw);
     tds->addAttribute(&r);
     tds->addAttribute(&tu);
     tds->addAttribute(&tl);
     tds->addAttribute(&hu);
     tds->addAttribute(&hl);
     tds->addAttribute(&l);
     tds->addAttribute(&kw);
     
     // Create the sobol object     
     Int_t ns = 100000;
     TSobol * tsobol = new TSobol(tds, &run, ns); 
     tsobol->setDrawProgressBar(kFALSE);
     tsobol->computeIndexes();
       
     if ( 1 ) {
       TCanvas *cc = new TCanvas("c1", "histgramme",5,64,1270,667);
       TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
       pad->Divide(2,1);
       pad->cd(1);
       tsobol->drawIndexes("Flowrate", "", "nonewcanv,hist,all");
       
       pad->cd(2);
       tsobol->drawIndexes("Flowrate", "", "nonewcanv,pie,first");
    
    }
  }
}

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval:

// Define the attributes
TUniformDistribution rw("rw", 0.05, 0.15);
TUniformDistribution r("r", 100.0, 50000.0);
TUniformDistribution tu("tu", 63070.0, 115600.0);
TUniformDistribution tl("tl", 63.1, 116.0);
TUniformDistribution hu("hu", 990.0, 1110.0);
TUniformDistribution hl("hl", 700.0, 820.0);
TUniformDistribution l("l", 1120.0, 1680.0);
TUniformDistribution kw("kw", 9855.0, 12045.0);

The interface to the function is then defined, using the Relauncher interface, through a TCIntEval object and a sequential runner:

 // Create the evaluator
TCIntEval code("flowrateModel");
// Create output attribute
TAttribute yout("flowrateModel");
// Provide input/output attributes to the assessor
code.setInputs(8, &rw, &r, &tu, &tl, &hu, &hl, &l, &kw);
code.setOutputs(1, &yout);

TSequentialRun run(&code); // To be replaced to distribute the computation
run.startSlave();

To instantiate the TSobol, one uses the TDataServer, a pointer to the runner and the number of samplings needed to perform sensitivity analysis (here ns=600):

TSobol * tsobol = new TSobol(tds, &run, ns);

Computation of the sensitivity indexes:

tsobol->computeIndexes();

Data are exported from the TDataServer to an ASCII file:

tds->exportData("_sobol_launching_.dat");

XIV.5.10.3. Graph

Figure XIV.52. Graph of the macro "sensitivitySobolFunctionFlowrateRunner.C"

Graph of the macro "sensitivitySobolFunctionFlowrateRunner.C"

XIV.5.10.4. Console

Processing sensitivitySobolFunctionFlowrateRunner.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[8099]
 <URANIE::WARNING> TDataServer::getTuple Error : There is no tree!
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::INFO> 
 <URANIE::INFO> *** URANIE INFORMATION ***
 <URANIE::INFO> *** File[${SOURCEDIR}/meTIER/sampler/souRCE/TSamplerStochastic.cxx] Line[66]
 <URANIE::INFO> TSamplerStochastic::init: the TDS [sobol] contains data: we need to empty it ! 
 <URANIE::INFO> *** END of URANIE INFORMATION ***
 <URANIE::INFO> 
 ** Case of Output atty [flowrateModel]  nSimPerIndex 10000
 ** Input att [rw] First [0.830033] Total Order[0.865762]
 ** Input att [r] First [0] Total Order[0.000102212]
 ** Input att [tu] First [0] Total Order[0.0001]
 ** Input att [tl] First [0] Total Order[0.000110756]
 ** Input att [hu] First [0.0417298] Total Order[0.0554922]
 ** Input att [hl] First [0.0367345] Total Order[0.0526188]
 ** Input att [l] First [0.0384214] Total Order[0.0535728]
 ** Input att [kw] First [0.00669831] Total Order[0.0132316]

XIV.5.11. Macro "sensitivityRegressionLeveLE.C"

Warning

The levele command will be installed on your machine only if a Fortran compiler is found

XIV.5.11.1. Objective

The objective of this macro is to perform a SRC and SRRC measurement on the temporal use-case levele. This use-case is an example of code that takes a dozen of entries in order to compute the evolution of dose as a function of time. The result of every computation consists in 3 vectors: the time (always the same value disregarding all entries), the dose called "y" and a third useless information.

XIV.5.11.2. Macro Uranie

{
  // OS abstraction
  string which_levele =
    string(gSystem->GetBuildArch()) == "win64" ? "where levele" : "which levele";

  //Exit if levele not found
  if(gSystem->Exec(which_levele.c_str()))
    exit(-1);

  //Create DataServer and add input attributes
  TDataServer *tds = new URANIE::DataServer::TDataServer("tds", "levelE usecase");
  tds->addAttribute( new TUniformDistribution("t", 100, 1000));
  tds->addAttribute( new TLogUniformDistribution("kl", 0.001, .01));
  tds->addAttribute( new TLogUniformDistribution("kc", 1.0e-6, 1.0e-5));
  tds->addAttribute( new TLogUniformDistribution("v1", 1.0e-3, 1.0e-1));
  tds->addAttribute( new TUniformDistribution("l1", 100., 500.));
  tds->addAttribute( new TUniformDistribution("r1", 1., 5.));
  tds->addAttribute( new TUniformDistribution("rc1", 3., 30.));
  tds->addAttribute( new TLogUniformDistribution("v2", 1.0e-2, 1.0e-1));
  tds->addAttribute( new TUniformDistribution("l2", 50., 200.));
  tds->addAttribute( new TUniformDistribution("r2", 1., 5.));
  tds->addAttribute( new TUniformDistribution("rc2", 3., 30.));
  tds->addAttribute( new TLogUniformDistribution("w", 1.0e5, 1.0e7));

  //Tell the code where to find attribute value in input file
  TString sIn = "levelE_input_with_values_rows.in";
  tds->getAttribute("t")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("kl")->setFileKey(sIn,"", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("kc")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("v1")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("l1")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("r1")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("rc1")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("v2")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("l2")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("r2")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("rc2")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);
  tds->getAttribute("w")->setFileKey(sIn, "", "%e",TAttributeFileKey::kNewRow);

  // Create DOE
  Int_t ns = 1024;
  TSampling *samp = new TSampling(tds, "lhs", ns);
  samp->generateSample();  

  //How to read ouput files
  TOutputFileRow *out = new TOutputFileRow("_output_levelE_withRow_.dat");
  //Tell the output file that attribute IS a vector and is SECOND column
  out->addAttribute(new TAttribute("y", TAttribute::kVector), 2 );

  //Creation of TCode
  TCode *myc = new TCode(tds," levele 2> /dev/null");
  myc->addOutputFile(out);

  //Run the code
  TLauncher * tl = new TLauncher(tds, myc);
  tl->run();

  //Launch Regression
  TRegression *tsen = new TRegression(tds, "t:kl:kc:v1:l1:r1:rc1:v2:l2:r2:rc2:w" , "y", "SRCSRRC");
  tsen->computeIndexes();
  TTree *res=tsen->getResultTuple();

  //Plotting mess
  double tps[26]={20000,30000,40000,50000,60000,70000,80000,90000,100000, 200000,300000,400000,500000,600000,700000,800000,900000, 1e+06,2e+06,3e+06,4e+06,5e+06,6e+06,7e+06,8e+06,9e+06};
  int colors[12] ={1,2,3,4,6,7,8,15,30,38,41,46};
  
  TCanvas *c2 = new TCanvas("c2","c2",5,64,1600,500);
  TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
  pad->Divide(3,1); pad->cd(1);
  gPad->SetLogx(); gPad->SetGrid();
  TMultiGraph *mg = new TMultiGraph();
  res->Draw("Value","Inp==\"__R2__\" && Order==\"Total\" && Method==\"SRRC^2\"","goff");
  double *data3=res->GetV1();
    
  TGraph *gr3 = new TGraph(26,tps,data3); gr3->SetMarkerColor(2); gr3->SetLineColor(2); gr3->SetMarkerStyle(23);
  mg->Add(gr3);
  res->Draw("Value","Inp==\"__R2__\" && Order==\"Total\" && Method==\"SRC^2\"","goff");
  double *data4=res->GetV1();
    
  TGraph *gr4 = new TGraph(26,tps,data4); gr4->SetMarkerColor(4); gr4->SetLineColor(4); gr4->SetMarkerStyle(23);
  mg->Add(gr4);
  mg->Draw("APC");
  mg->GetXaxis()->SetTitle("Time");
  mg->GetYaxis()->SetTitle("#sum Sobol");
  mg->GetYaxis()->SetRangeUser(0.0,1.0);

  //Legend
  gStyle->SetLegendBorderSize(0);
  gStyle->SetFillStyle(0);

  TLegend *lg = new TLegend(0.25,0.7,0.45,0.9);
  lg->AddEntry(gr4,"R2 SRC","lp");
  lg->AddEntry(gr3,"R2 SRRC","lp");
  lg->Draw();

  
  pad->cd(2);  gPad->SetLogx();  gPad->SetGrid();
  TMultiGraph *mg2 = new TMultiGraph();

  string names[12] = {"t","kl","kc","v1","l1","r1","rc1","v2","l2","r2","rc2","w"};
  TGraph *src[12];
  TLegend *leg = new TLegend(0.25,0.3,0.45,0.89,"Cumulative contributions");
  leg->SetTextSize(0.035);
  for(unsigned int igr=0; igr<12; igr++)
  {
    string sel="Inp==\""+names[igr]+"\" && Order==\"Total\" && Method==\"SRC^2\" && Algo!=\"--rho^2--\"";
    res->Draw("Value", sel.c_str(),"goff");
    double *data=res->GetV1();
    src[igr] = new TGraph();
    src[igr]->SetMarkerColor(colors[igr]); src[igr]->SetLineColor(colors[igr]);  src[igr]->SetFillColor(colors[igr]);

    src[igr]->SetPoint(0, 0.99999999*tps[0], 0);
    for(unsigned int ip=0; ip<26; ip++)
    {
      double x=0, y=0;
      if(igr!=0)
        src[igr-1]->GetPoint(ip+1,x,y);
      src[igr]->SetPoint(ip+1, tps[ip], y+data[ip]);
    }
    src[igr]->SetPoint(27, tps[25]*1.000000001, 0);
    leg->AddEntry(src[igr],names[igr].c_str(),"f");
  }

  for(int igr2=11; igr2>-1; igr2--)
    mg2->Add(src[igr2]);
  
  mg2->Draw("AFL");
  mg2->GetXaxis()->SetTitle("Time");
  mg2->GetYaxis()->SetTitle("SRC^{2}");
  mg2->GetYaxis()->SetRangeUser(0.0,0.3);
  leg->Draw();
  
  pad->cd(3); gPad->SetLogx(); gPad->SetGrid();
  TMultiGraph *mg3 = new TMultiGraph();
  TGraph *srrc[12];
  for(unsigned int igr=0; igr<12; igr++)
  {
    string sel="Inp==\""+names[igr]+"\" && Order==\"Total\" && Method==\"SRRC^2\" && Algo!=\"--rho^2--\"";
    res->Draw("Value", sel.c_str(),"goff");
    double *data=res->GetV1();
    srrc[igr] = new TGraph();
    srrc[igr]->SetMarkerColor(colors[igr]); srrc[igr]->SetLineColor(colors[igr]);  srrc[igr]->SetFillColor(colors[igr]);

    srrc[igr]->SetPoint(0, 0.99999999*tps[0], 0);
    for(unsigned int ip=0; ip<26; ip++)
    {
      double x=0, y=0;
      if(igr!=0)
        srrc[igr-1]->GetPoint(ip+1,x,y);
      srrc[igr]->SetPoint(ip+1, tps[ip], y+data[ip]);
    }
    srrc[igr]->SetPoint(27, tps[25]*1.000000001, 0);
    srrc[igr]->SetTitle( names[igr].c_str() );
  }

  for(int igr2=11; igr2>-1; igr2--)
    mg3->Add(srrc[igr2]);
  
  //  mg3->Draw("a fb l3d");
  mg3->Draw("AFL");
  mg3->GetXaxis()->SetTitle("Time");
  mg3->GetYaxis()->SetTitle("SRRC^{2}");
  mg3->GetYaxis()->SetRangeUser(0.0,1.0);
  leg->Draw();
  
}

The levele external code is located in the bin directory of the Uranie installation.

When looking at the code and comparing it to an usual Regression estimation, the organisation is completely transparent. The only noticeable (and compulsory) thing to do is to change the default type of the attribute read at the end of the job. This is done in this line:

out->addAttribute(new TAttribute("y", TAttribute::kVector), 2 );

where the output attribute is provided, changing its nature to a vector, thanks to the second argument of the TAttribute constructor from the default (kReal) to the desired nature (kVector). Once this is done, this information is broadcast internally to the code that knows how to deal with this type of attribute.

The rest of the code is the graphical part, leading to the figure below (it is provided to illustrate how to represent results).

XIV.5.11.3. Graph

The results of the previous macro is shown in Figure XIV.53, where the left panel represents the value of the coefficients both the SRC and SRRC coefficients estimation. The middle and right panel display the cumulative sum of the quadratic value of the coefficient respectively for the SRC and SRRC case.

Figure XIV.53. Graph of the macro "sensitivityRegressionLeveLE.C"

Graph of the macro "sensitivityRegressionLeveLE.C"

XIV.5.12. Macro "sensitivitySobolLeveLE.C"

Warning

The levele command will be installed on your machine only if a Fortran compiler is found

XIV.5.12.1. Objective

The objective of this macro is to perform a full Sobol analysis on the temporal use-case levele. This use-case is an example of code that takes a dozen of entries in order to compute the evolution of dose as a function of time. The result of every computation consists in 3 vectors: the time (always the same value disregarding all entries), the dose called "y" and a third useless information.

XIV.5.12.2. Macro Uranie

{
  // OS abstraction
  string which_levele =
    string(gSystem->GetBuildArch()) == "win64" ? "where levele" : "which levele";

  //Exit if levele not found
  if(gSystem->Exec(which_levele.c_str()))
    exit(-1);
  
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsLevelE","levele");
  tds->addAttribute( new TUniformDistribution("t", 100, 1000) );
  tds->addAttribute( new TLogUniformDistribution("kl", 0.001, 0.01) );
  tds->addAttribute( new TLogUniformDistribution("kc", 0.000001, 0.00001) );
  tds->addAttribute( new TLogUniformDistribution("v1", 0.001, 0.1) );
  tds->addAttribute( new TUniformDistribution("l1", 100, 500) );
  tds->addAttribute( new TUniformDistribution("r1", 1, 5) );
  tds->addAttribute( new TUniformDistribution("rc1", 3, 30) );
  tds->addAttribute( new TLogUniformDistribution("v2", 0.01, 0.1) );
  tds->addAttribute( new TUniformDistribution("l2", 50, 200) );
  tds->addAttribute( new TUniformDistribution("r2", 1, 5) );
  tds->addAttribute( new TUniformDistribution("rc2", 3, 30) );
  tds->addAttribute( new TLogUniformDistribution("w", 100000, 10000000) );

  //Tell the code where to find attribute value in input file
  TString sIn="levelE_input_with_values_rows.in";
  tds->getAttribute("t")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("kl")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("kc")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("v1")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("l1")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("r1")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("rc1")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("v2")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("l2")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("r2")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("rc2")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);
  tds->getAttribute("w")->setFileKey(sIn, "", "%e", TAttributeFileKey::kNewRow);

  //How to read ouput files
  TOutputFileRow *out = new TOutputFileRow("_output_levelE_withRow_.dat");
  //Tell the output file that attribute IS a vector and is SECOND column
  out->addAttribute(new TAttribute("y", TAttribute::kVector), 2 );

  //Creation of TCode
  TCode *myc = new TCode(tds,"levele 2> /dev/null");
  myc->addOutputFile(out);

  //Run Sobol analysis
  TSobol * tsobol = new TSobol(tds, myc, 10000);
  tsobol->computeIndexes();

  TTree *ntresu = (TTree*)tsobol->getResultTuple();

  //Plotting mess  
  int colors[12] ={1,2,3,4,6,7,8,15,30,38,41,46};
  double tps[26]={20000,30000,40000,50000,60000,70000,80000,90000,100000, 200000,300000,400000,500000,600000,700000,800000,900000, 1e+06,2e+06,3e+06,4e+06,5e+06,6e+06,7e+06,8e+06,9e+06};
  
  TCanvas *c2 = new TCanvas("c2","c2",5,64,1200,900);
  TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
  pad->Divide(1,2); pad->cd(1); gPad->SetLogx();  gPad->SetGrid();

  //LegendandMArker
  gStyle->SetMarkerStyle(3);
  gStyle->SetLegendBorderSize(0);
  gStyle->SetFillStyle(0);

  TMultiGraph *mg2 = new TMultiGraph();
  string names[12] = {"t","kl","kc","v1","l1","r1","rc1","v2","l2","r2","rc2","w"};
  TGraphAsymmErrors *fdeg[12];
  TLegend *leg[6]; double *data, *themin, *themax;
  
  for(unsigned int igr=0; igr<12; igr++)
  {
    stringstream sel; sel << "Inp==\"" << names[igr] << "\" && Order==\"First\" &&  Algo==\"martinez11\"";
    ntresu->Draw("CILower:CIUpper:Value", sel.str().c_str(),"goff");
    data=ntresu->GetV3();
    themin=ntresu->GetV1(); 
    themax=ntresu->GetV2(); 
    for(unsigned int i=0; i<26; i++)
      {
	themin[i] = data[i] - themin[i];
	themax[i] = - data[i] + themax[i];
      }
    
    if(igr%2==0)
      {
	leg[igr/2] = new TLegend(0.1+0.15*(igr/2),0.91,0.25+0.15*(igr/2),0.98);
	leg[igr/2]->SetTextSize(0.045);
      }

    fdeg[igr] = new TGraphAsymmErrors(26,tps, data,0, 0, themin, themax);
    fdeg[igr]->SetMarkerColor(colors[igr]); fdeg[igr]->SetLineColor(colors[igr]);  fdeg[igr]->SetFillColor(colors[igr]);
    leg[igr/2]->AddEntry(fdeg[igr],names[igr].c_str(),"pl");
  }

  for(int igr2=11; igr2>-1; igr2--)
    mg2->Add(fdeg[igr2]);
  
  mg2->Draw("APC");
  mg2->GetXaxis()->SetTitle("Time");
  mg2->GetYaxis()->SetTitle("S_{1}[martinez11]");
  for( int igr3=0; igr3<6; igr3++ )
    leg[igr3]->Draw();

    
  TMultiGraph *mg = new TMultiGraph();
  TGraphAsymmErrors *tdeg[12];
  pad->cd(2); gPad->SetLogx(); gPad->SetGrid(); 
  for(unsigned int igr=0; igr<12; igr++)
  {
    stringstream sel; sel << "Inp==\"" << names[igr] << "\" && Order==\"Total\" &&  Algo==\"martinez11\"";
    ntresu->Draw("CILower:CIUpper:Value", sel.str().c_str(),"goff");
    data=ntresu->GetV3();
    themin=ntresu->GetV1();
    themax=ntresu->GetV2();
    for(unsigned int i=0; i<26; i++)
      {
	themin[i] = data[i] - themin[i];
	themax[i] = - data[i] + themax[i];
      }

    
    for(unsigned int ip=0; ip<26; ip++)
      {
  	if(ip==0)
  	  {
  	    tdeg[igr] = new TGraphAsymmErrors();
  	    tdeg[igr]->SetMarkerColor(colors[igr]); tdeg[igr]->SetLineColor(colors[igr]);  tdeg[igr]->SetFillColor(colors[igr]);
  	  }

  	tdeg[igr]->SetPoint(ip, tps[ip], data[ip]);	
	tdeg[igr]->SetPointError(ip, 0, 0, themin[ip], themax[ip]);

      }
  }

  for(int igr2=11; igr2>-1; igr2--)
    mg->Add(tdeg[igr2]);
  
  mg->Draw("APC");
  mg->GetXaxis()->SetTitle("Time");
  mg->GetYaxis()->SetTitle("S_{T}[martinez11]");
  for( int igr3=0; igr3<6; igr3++ )
    leg[igr3]->Draw();
   
}

The levele external code is located in the bin directory of the Uranie installation.

When looking at the code and comparing it to an usual Sobol estimation, the organisation is completely transparent. The only noticeable (and compulsory) thing to do is to change the default type of the attribute read at the end of the job. This is done in this line:

out->addAttribute(new TAttribute("y", TAttribute::kVector), 2 );

where the output attribute is provided, changing its nature to a vector, thanks to the second argument of the TAttribute constructor from the default (kReal) to the desired nature (kVector). Once this is done, this information is broadcast internally to the code that knows how to deal with this type of attribute.

The rest of the code is the graphical part, leading to the figure below (it is provided to illustrate how to represent results).

XIV.5.12.3. Graph

The results of the previous macro is shown in Figure XIV.54, where the evolution of the sobol coefficient is shown for all inputs with the uncertainty band, for the first order coefficient and the total one, respectively on the top and bottom panel.

Figure XIV.54. Graph of the macro "sensitivitySobolLeveLE.C"

Graph of the macro "sensitivitySobolLeveLE.C"

XIV.5.13. Macro "sensitivitySobolRe-estimation.C"

XIV.5.13.1. Objective

The objective of this macro is to perform a full Sobol analysis using the existing file created when the Sobol class is allowed to perform the design-of-experiments and the estimations by itself (see the first item in the tip box in Section VI.5.2 for more details). This would mean that the only computation done would be to estimate the coefficients (no external code / function called).

Warning

The ref_sobol_launching_.dat file used as input is not provided in the usual sub-directory "/share/uranie/macros" of the installation folder of Uranie ($URANIESYS) but can be generated by the user by running the macro discussed in Section XIV.5.9.

XIV.5.13.2. Macro Uranie

{
   
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
  tds->fileDataRead("ref_sobol_launching_.dat");
  
  TSobol * tsobol = new TSobol(tds, "rw:r:tu:tl:hu:hl:l:kw", "flowrateModel");
  tsobol->computeIndexes();
      
  TCanvas *cc = new TCanvas("c1", "histgramme",5,64,1270,667);
  TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
  pad->Divide(2,1);
  pad->cd(1);
  tsobol->drawIndexes("Flowrate", "", "nonewcanv,hist,all");
  
  pad->cd(2);
  tsobol->drawIndexes("Flowrate", "", "nonewcanv,pie,first");
    
}

There are no external code or function to be run here. The input file ref_sobol_launching_.dat has to be generated by the use of sensitivtySobolFunctionFlowrate.C. Once done it is loaded into the dataserver and the TSobol object is constructed from the simplest constructor with only the pointer to the dataserver, the input and output list:

 TSobol * tsobol = new TSobol(tds, "rw:r:tu:tl:hu:hl:l:kw", "flowrateModel"); 

Once done, the computeIndexes() method is called and few lines are shown to display the results in the classical plot form, leading to the figure below (it is provided to illustrate how to represent results). The numerical results are shown in the console below and are identical to the ones shown in Section XIV.5.9.4 from where the full sample is coming from.

XIV.5.13.3. Graph

The results of the previous macro is shown in Figure XIV.55, where the evolution of the sobol coefficient is shown for all inputs with the uncertainty band, for the first order coefficient and the total one, respectively on the top and bottom panel.

Figure XIV.55. Graph of the macro "sensitivitySobolRe-estimation.C"

Graph of the macro "sensitivitySobolRe-estimation.C"

XIV.5.13.4. Console

Processing sensitivitySobolRe-estimation.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

 ** Case of Output atty [flowrateModel]  nSimPerIndex 10000
 ** Input att [rw] First [0.830033] Total Order[0.865762]
 ** Input att [r] First [0] Total Order[0.000102212]
 ** Input att [tu] First [0] Total Order[0.0001]
 ** Input att [tl] First [0] Total Order[0.000110756]
 ** Input att [hu] First [0.0417298] Total Order[0.0554922]
 ** Input att [hl] First [0.0367345] Total Order[0.0526188]
 ** Input att [l] First [0.0384214] Total Order[0.0535728]
 ** Input att [kw] First [0.00669831] Total Order[0.0132316]

XIV.5.14. Macro "sensitivitySobolWithData.C"

XIV.5.14.1. Objective

The objective of this macro is to perform a Sobol analysis using the some already made computations in order to be able to save ressources. The idea (discussed in the second item in the tip box in Section VI.5.2 is indeed to use the provided points as the first estimations corresponding to both the and matrices content. The class will still have to create all the cross configurations (the matrices) and launch their corresponding estimations. In order to do that there are few things to keep in mind:

  • The input file (here _onlyMandN_sobol_launching_.dat) should contains input and output variables only, the user being in charge of having a decent design-of-experiments for the sobol estimation.

Warning

The _onlyMandN_sobol_launching_.dat file used as input is not provided in the usual sub-directory "/share/uranie/macros" of the installation folder of Uranie ($URANIESYS) but can be generated by the user by running the macro discussed in Section XIV.5.9.

XIV.5.14.2. Macro Uranie

{

  gROOT->LoadMacro("UserFunctions.C");  
   
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
  tds->fileDataRead("_onlyMandN_sobol_launching_.dat");

  int ns=10000;
  TSobol * tsobol = new TSobol(tds, "flowrateModel", ns, "rw:r:tu:tl:hu:hl:l:kw", "flowrateModel", "WithData"); 
  tsobol->setDrawProgressBar(kFALSE);
  tsobol->computeIndexes();
      
  TCanvas *cc = new TCanvas("c1", "histgramme",5,64,1270,667);
  TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
  pad->Divide(2,1);
  pad->cd(1);
  tsobol->drawIndexes("Flowrate", "", "nonewcanv,hist,all");
  
  pad->cd(2);
  tsobol->drawIndexes("Flowrate", "", "nonewcanv,pie,first");
    
}

As for Section XIV.5.9, the UserFunctions.C file is loaded and the input file _onlyMandN_sobol_launching_.dat (which should have been generated by the use of sensitivtySobolFunctionFlowrate.C), is loaded into the dataserver. The TSobol object is constructed from the usual function constructor with a noticing difference: the option field is filled with WithData to specify that data are already there and the code has to use these data and split them into both the and matrices.

TSobol * tsobol = new TSobol(tds, "flowrateModel", ns, "rw:r:tu:tl:hu:hl:l:kw", "flowrateModel", "WithData");

Once done, the computeIndexes() method is called and few lines are shown to display the results in the classical plot form, leading to the figure below (it is provided to illustrate how to represent results). The numerical results are shown in the console below and are identical to the ones shown in Section XIV.5.9.4 from where the original set of points is coming from.

XIV.5.14.3. Graph

The results of the previous macro is shown in Figure XIV.56, where the evolution of the sobol coefficient is shown for all inputs with the uncertainty band, for the first order coefficient and the total one, respectively on the top and bottom panel.

Figure XIV.56. Graph of the macro "sensitivitySobolWithData.C"

Graph of the macro "sensitivitySobolWithData.C"

XIV.5.14.4. Console

Processing sensitivitySobolWithData.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

 ** Case of Output atty [flowrateModel]  nSimPerIndex 10000
 ** Input att [rw] First [0.830033] Total Order[0.865762]
 ** Input att [r] First [0] Total Order[0.000102212]
 ** Input att [tu] First [0] Total Order[0.0001]
 ** Input att [tl] First [0] Total Order[0.000110756]
 ** Input att [hu] First [0.0417298] Total Order[0.0554922]
 ** Input att [hl] First [0.0367345] Total Order[0.0526188]
 ** Input att [l] First [0.0384214] Total Order[0.0535728]
 ** Input att [kw] First [0.00669831] Total Order[0.0132316]

XIV.5.15. Macro "sensitivitySobolLoadFile.C"

XIV.5.15.1. Objective

The objective of this macro is to perform a full Sobol analysis using the existing file created when the Sobol class is allowed to perform the design-of-experiments and the estimations by itself when this one is not considered accurate enough (from the statistical point of view). The idea is to use anyway all the computations already done and generate some more to increase the statistical precision. In order to do that there are few things to keep in mind:

  • The problem should obviously be exactly the same: same input and output (name, statistical laws, parameter values...).

  • The input file (here ref_sobol_launching_.dat) should contains the internal variable in order to figure out from what matrices every configuration is taken out of (generally an iterator whose name should look like sobol__n__iter__ plus the dataserver name).

  • If the pseudo-random generator seed is set to a given value, bBe sure that you are not be using the same seed than the once used to generate the input file, which would lead to twice the same events.

One can find another discussion for this objective in the third item in the tip box in Section VI.5.2.

Warning

The ref_sobol_launching_.dat file used as input is not provided in the usual sub-directory "/share/uranie/macros" of the installation folder of Uranie ($URANIESYS) but can be generated by the user by running the macro discussed in Section XIV.5.9.

XIV.5.15.2. Macro Uranie

{

  gROOT->LoadMacro("UserFunctions.C");  
   
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
  tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
  tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
  tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
  tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
  tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
  tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
  tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
  tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

  int ns=100000;
  TSobol * tsobol = new TSobol(tds, "flowrateModel", ns, "rw:r:tu:tl:hu:hl:l:kw", "flowrateModel");  
  tsobol->loadOtherSobolFile("ref_sobol_launching_.dat");
  tsobol->setDrawProgressBar(kFALSE);
  tsobol->computeIndexes();

  tsobol->getResultTuple()->Scan("*","Algo==\"--first--\" || Algo==\"--total--\"");
      
  TCanvas *cc = new TCanvas("c1", "histgramme",5,64,1270,667);
  TPad *pad = new TPad("pad","pad",0, 0.03, 1, 1); pad->Draw();
  pad->Divide(2,1);
  pad->cd(1);
  tsobol->drawIndexes("Flowrate", "", "nonewcanv,hist,all");
  
  pad->cd(2);
  tsobol->drawIndexes("Flowrate", "", "nonewcanv,pie,first");
    
}

As for Section XIV.5.9, the UserFunctions.C file is loaded and all the input stochastic distribution are chosen wisely. The number of new estimations is set (to 10000, doubling the statistic as this is also the number used in Section XIV.5.9 which provided the input file that would be used to complete this estimation).

All the code lines are exactly those taken out of Section XIV.5.9.2 but the one that is used to load a previous estimation which is shown below:

tsobol->loadOtherSobolFile("ref_sobol_launching_.dat");

Once done, the computeIndexes() method is called and few lines are shown to display the results in the classical plot form, leading to the figure below (it is provided to illustrate how to represent results). The numerical results are shown in the console below and the improvement in terms of statistical precision can be seen by comparing the 95 percent confidence intervals going from Section XIV.5.9.4 to Section XIV.5.15.4.

XIV.5.15.3. Graph

The results of the previous macro is shown in Figure XIV.57, where the evolution of the sobol coefficient is shown for all inputs with the uncertainty band, for the first order coefficient and the total one, respectively on the top and bottom panel.

Figure XIV.57. Graph of the macro "sensitivitySobolLoadFile.C"

Graph of the macro "sensitivitySobolLoadFile.C"

XIV.5.15.4. Console

Processing sensitivitySobolLoadFile.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[759]
 <URANIE::WARNING> TDataServer::fileDataRead: Expected iterator tdsflowreate_1__n__iter__ not found but tdsflowreate__n__iter__ looks like an URANIE iterator => Will be used as so.
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[8099]
 <URANIE::WARNING> TDataServer::getTuple Error : There is no tree!
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::INFO> 
 <URANIE::INFO> *** URANIE INFORMATION ***
 <URANIE::INFO> *** File[${SOURCEDIR}/meTIER/sampler/souRCE/TSamplerStochastic.cxx] Line[66]
 <URANIE::INFO> TSamplerStochastic::init: the TDS [tdsflowreate] contains data: we need to empty it ! 
 <URANIE::INFO> *** END of URANIE INFORMATION ***
 <URANIE::INFO> 
 ** Case of Output atty [flowrateModel]  nSimPerIndex 20000
 ** Input att [rw] First [0.823516] Total Order[0.873849]
 ** Input att [r] First [0] Total Order[5.22438e-05]
 ** Input att [tu] First [0] Total Order[5e-05]
 ** Input att [tl] First [0] Total Order[6.08391e-05]
 ** Input att [hu] First [0.0319889] Total Order[0.0547724]
 ** Input att [hl] First [0.0304453] Total Order[0.0540884]
 ** Input att [l] First [0.0315935] Total Order[0.0527791]
 ** Input att [kw] First [0] Total Order[0.0129065]
************************************************************************************************************
*    Row   *   Out.Out *   Inp.Inp * Order.Ord * Method.Me * Algo.Algo * Value.Val * CILower.C * CIUpper.C *
************************************************************************************************************
*        0 * flowrateM *        rw *     First *     Sobol * --first-- * 0.8235162 * 0.8190045 * 0.8279262 *
*        4 * flowrateM *        rw *     Total *     Sobol * --total-- * 0.8738492 * 0.8602341 * 0.8875120 *
*        8 * flowrateM *         r *     First *     Sobol * --first-- *         0 *         0 * 0.0138594 *
*       12 * flowrateM *         r *     Total *     Sobol * --total-- * 5.224e-05 * 5.081e-05 * 5.371e-05 *
*       16 * flowrateM *        tu *     First *     Sobol * --first-- *         0 *         0 * 0.0138594 *
*       20 * flowrateM *        tu *     Total *     Sobol * --total-- * 5.000e-05 * 4.863e-05 * 5.140e-05 *
*       24 * flowrateM *        tl *     First *     Sobol * --first-- *         0 *         0 * 0.0138594 *
*       28 * flowrateM *        tl *     Total *     Sobol * --total-- * 6.083e-05 * 5.917e-05 * 6.254e-05 *
*       32 * flowrateM *        hu *     First *     Sobol * --first-- * 0.0319888 * 0.0181374 * 0.0458280 *
*       36 * flowrateM *        hu *     Total *     Sobol * --total-- * 0.0547723 * 0.0533147 * 0.0562686 *
*       40 * flowrateM *        hl *     First *     Sobol * --first-- * 0.0304453 * 0.0165929 * 0.0442861 *
*       44 * flowrateM *        hl *     Total *     Sobol * --total-- * 0.0540884 * 0.0526485 * 0.0555665 *
*       48 * flowrateM *         l *     First *     Sobol * --first-- * 0.0315935 * 0.0177418 * 0.0454330 *
*       52 * flowrateM *         l *     Total *     Sobol * --total-- * 0.0527791 * 0.0513732 * 0.0542224 *
*       56 * flowrateM *        kw *     First *     Sobol * --first-- *         0 *         0 * 0.0138594 *
*       60 * flowrateM *        kw *     Total *     Sobol * --total-- * 0.0129065 * 0.0125558 * 0.0132669 *
*       64 * flowrateM *   __sum__ *     First *     Sobol * --first-- * 0.9175440 *        -1 *        -1 *
*       65 * flowrateM *   __sum__ *     Total *     Sobol * --total-- * 1.0485587 *        -1 *        -1 *
************************************************************************************************************
==> 18 selected entries

XIV.5.16. Macro "sensitivityJohnsonRWFunctionFlowrate.C"

XIV.5.16.1. Objective

The objective of this macro is to perform a sensitivity analysis using the Johnson's relative weight method on a set of eight parameters used in the flowrateModel model described in Section IV.1.2.1.

XIV.5.16.2. Macro Uranie

{  
  gROOT->LoadMacro("UserFunctions.C");
        
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowrate", "DataBase flowrate");
  tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
  tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
  tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
  tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
  tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
  tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
  tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
  tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
    
  // \param Size of a sampling.
  Int_t nS = 1000;
  TString FuncName="flowrateModel";
 
  TJohnsonRW *tjrw = new TJohnsonRW(tds, FuncName, nS, "rw:r:tu:tl:hu:hl:l:kw", FuncName); 
  tjrw->computeIndexes();

  // Get the results on screen 
  tjrw->getResultTuple()->Scan("Out:Inp:Method:Value","Order==\"First\"");

  // Get the results as plots
  TCanvas *cc = new TCanvas("canhist", "histgramme");
  tjrw->drawIndexes("Flowrate", "", "nonewcanv,hist,first"); 
  cc->Print("appliUranieFlowrateJohnsonRW1000Histogram.png"); 

  TCanvas *ccc = new TCanvas("canpie", "TPie");
  tjrw->drawIndexes("Flowrate", "", "nonewcanv,pie"); 
  ccc->Print("appliUranieFlowrateJohnsonRW1000Pie.png"); 
  
}

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval

TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

To instantiate the TJohnsonRW object, one uses the TDataServer, the name of the function, the number of samplings needed to perform sensitivity analysis (here =4000) and the input and output variables:

TJohnsonRW * tjrw = new TJohnsonRW(tds, FuncName, nS, "rw:r:tu:tl:hu:hl:l:kw", FuncName);

Computation of sensitivity indexes:

trbd->computeIndexes();

The rest is very common to all sensitivity macros discussed here: it will produce two plots (the first one being a histogram show below) and the console is also shown below for completness.

XIV.5.16.3. Graph

Figure XIV.58. Graph of the macro "sensitivityJohnsonRWFunctionFlowrate.C"

Graph of the macro "sensitivityJohnsonRWFunctionFlowrate.C"

XIV.5.16.4. Console

Processing sensitivityJohnsonRWFunctionFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[8099]
 <URANIE::WARNING> TDataServer::getTuple Error : There is no tree!
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::INFO> 
 <URANIE::INFO> *** URANIE INFORMATION ***
 <URANIE::INFO> *** File[${SOURCEDIR}/meTIER/sampler/souRCE/TSamplerStochastic.cxx] Line[66]
 <URANIE::INFO> TSamplerStochastic::init: the TDS [tdsflowrate] contains data: we need to empty it ! 
 <URANIE::INFO> *** END of URANIE INFORMATION ***
 <URANIE::INFO> 
************************************************************
*    Row   *       Out *       Inp *    Method *     Value *
************************************************************
*        0 * flowrateM *        rw * JohnsonRW * 0.8636266 *
*        2 * flowrateM *         r * JohnsonRW * 4.598e-05 *
*        4 * flowrateM *        tu * JohnsonRW * 8.775e-06 *
*        6 * flowrateM *        tl * JohnsonRW * 9.689e-05 *
*        8 * flowrateM *        hu * JohnsonRW * 0.0439173 *
*       10 * flowrateM *        hl * JohnsonRW * 0.0435594 *
*       12 * flowrateM *         l * JohnsonRW * 0.0378304 *
*       14 * flowrateM *        kw * JohnsonRW * 0.0109144 *
*       16 * flowrateM *    __R2__ * JohnsonRW * 0.9447092 *
*       18 * flowrateM *   __R2A__ * JohnsonRW * 0.9442633 *
************************************************************
==> 10 selected entries

XIV.5.17. Macro "sensitivityJohnsonRWCorrelatedFunctionFlowrate.C"

XIV.5.17.1. Objective

The objective of this macro is to perform a sensitivity analysis using the Johnson's relative weight method on a set of eight parameters used in the flowrateModel model described in Section IV.1.2.1. Compared to version detailled in Section XIV.5.16, the idea is here to correlate the input variables with a random correlation matrix.

XIV.5.17.2. Macro Uranie


// Function defined to generate randomly a good, highly-correlated, input correlation matrix
TMatrixD GenCorr(int _nX=8, bool correlated=true)
{

    gRandom->SetSeed(__rdtsc());
    //Define a randomly filled matrix 
    TMatrixD A(_nX,_nX);
    for (int i=0; i<_nX; i++)
        for (int j=0; j<_nX; j++)
            A(i,j)=gRandom->Gaus(0,1);

    // Compute AA^T and normalise it to get "covariance matrix"
    TMatrixD Gamma(A,TMatrixD::kMultTranspose,A);
    Gamma*=1./_nX;

    // Get the inverse of the diagonal matrix to do as if this was 1/sqrt(variance)
    TMatrixD Sig(_nX,_nX);
    for(int i=0;i<_nX;i++) Sig(i,i)=1./sqrt( Gamma(i,i) );

    // Compute the correlation matrix 
    TMatrixD Corr(Sig*Gamma,TMatrixD::kMult, Sig);
    if( !correlated )
        Corr.UnitMatrix();

    return Corr;    
}


void sensitivityJohnsonRWCorrelatedFunctionFlowrate()
{  
  gROOT->LoadMacro("UserFunctions.C");
        
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowrate", "DataBase flowrate");
  tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
  tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
  tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
  tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
  tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
  tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
  tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
  tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
    
  // \param Size of a sampling.
  Int_t nS = 1000;
  TString FuncName="flowrateModel";
  
  // Get a correlation matrix for the inputs
  TMatrixD inCorr=GenCorr(8,true);
  inCorr.Print();
  
  TJohnsonRW *tjrw = new TJohnsonRW(tds, FuncName, nS, "rw:r:tu:tl:hu:hl:l:kw", FuncName); 
  //Set the correlation
  tjrw->setInputCorrelationMatrix(inCorr);
  tjrw->computeIndexes();

  // Get the results on screen 
  tjrw->getResultTuple()->Scan("Out:Inp:Method:Value","Order==\"First\"");

  // Get the results as plots
  TCanvas *cc = new TCanvas("canhist", "histgramme");
  tjrw->drawIndexes("Flowrate", "", "nonewcanv,hist,first"); 
  cc->Print("appliUranieFlowrateJohnsonRWCorrelated1000Histogram.png"); 

  TCanvas *ccc = new TCanvas("canpie", "TPie");
  tjrw->drawIndexes("Flowrate", "", "nonewcanv,pie"); 
  ccc->Print("appliUranieFlowrateJohnsonRWCorrelated1000Pie.png"); 
  
}

The first function, called GenCorr, is not discussed, because it is really technical and not really interesting here. The only thing to know is that it provides a proper correlation matrix: a positive-definite symmetrical matrix.

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Compared to the discussion in Section XIV.5.16.2, the instantiation of the attributes and the TJohnsonRW object is the same. The only difference is done when injecting the correlation matrix, which is done in these lines:

// Get a correlation matrix for the inputs
TMatrixD inCorr=GenCorr(8,true);
//Set the correlation
tjrw->setInputCorrelationMatrix(inCorr);

The computation of sensitivity indices can finally be done:

trbd->computeIndexes();

The rest is very common to all sensitivity macros discussed here: it will produce two plots (the first one being a histogram show below) and the console is also shown below for completness.

XIV.5.17.3. Graph

Figure XIV.59. Graph of the macro "sensitivityJohnsonRWCorrelatedFunctionFlowrate.C"

Graph of the macro "sensitivityJohnsonRWCorrelatedFunctionFlowrate.C"

XIV.5.17.4. Console

Processing sensitivityJohnsonRWCorrelatedFunctionFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024


8x8 matrix is as follows

     |      0    |      1    |      2    |      3    |      4    |
----------------------------------------------------------------------
   0 |          1      0.4488      0.2894    -0.05727      0.3627 
   1 |     0.4488           1     0.02022     -0.2547      0.3764 
   2 |     0.2894     0.02022           1      0.4982     -0.2078 
   3 |   -0.05727     -0.2547      0.4982           1     -0.9199 
   4 |     0.3627      0.3764     -0.2078     -0.9199           1 
   5 |     0.2569     -0.1996      -0.288      0.1004     -0.1362 
   6 |    -0.2167     -0.4425    0.004268      0.1412      -0.111 
   7 |    -0.2948      0.1982   -0.001661      0.1943     -0.3131 


     |      5    |      6    |      7    |
----------------------------------------------------------------------
   0 |     0.2569     -0.2167     -0.2948 
   1 |    -0.1996     -0.4425      0.1982 
   2 |     -0.288    0.004268   -0.001661 
   3 |     0.1004      0.1412      0.1943 
   4 |    -0.1362      -0.111     -0.3131 
   5 |          1     -0.1943      0.2848 
   6 |    -0.1943           1     -0.4415 
   7 |     0.2848     -0.4415           1 

 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[8099]
 <URANIE::WARNING> TDataServer::getTuple Error : There is no tree!
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::INFO> 
 <URANIE::INFO> *** URANIE INFORMATION ***
 <URANIE::INFO> *** File[${SOURCEDIR}/meTIER/sampler/souRCE/TSamplerStochastic.cxx] Line[66]
 <URANIE::INFO> TSamplerStochastic::init: the TDS [tdsflowrate] contains data: we need to empty it ! 
 <URANIE::INFO> *** END of URANIE INFORMATION ***
 <URANIE::INFO> 
************************************************************
*    Row   *       Out *       Inp *    Method *     Value *
************************************************************
*        0 * flowrateM *        rw * JohnsonRW * 0.5113911 *
*        2 * flowrateM *         r * JohnsonRW * 0.1409327 *
*        4 * flowrateM *        tu * JohnsonRW * 0.0505176 *
*        6 * flowrateM *        tl * JohnsonRW * 0.0482684 *
*        8 * flowrateM *        hu * JohnsonRW * 0.0969452 *
*       10 * flowrateM *        hl * JohnsonRW * 0.0306674 *
*       12 * flowrateM *         l * JohnsonRW * 0.0836757 *
*       14 * flowrateM *        kw * JohnsonRW * 0.0376016 *
*       16 * flowrateM *    __R2__ * JohnsonRW * 0.9500813 *
*       18 * flowrateM *   __R2A__ * JohnsonRW * 0.9496787 *
************************************************************
==> 10 selected entries

XIV.5.18. Macro "sensitivityJohnsonRWJustCorrelationFakeFlowrate.C"

XIV.5.18.1. Objective

The objective of this macro is to perform a sensitivity analysis using the Johnson's relative weight method on a set of eight parameters which IS NOT the usual flowrateModel model. Indeed, compared to version detailled in Section XIV.5.17, the idea is here to correlate the input variables with a random correlation matrix and to translate this into a full correlation matrix, meaning defining a "fake" output by computing their covariance with every input as if this output was a perfect linear combination of these inputs.

An important particularity of this study is that no data are generated at all, it only uses the correlation matrix.

XIV.5.18.2. Macro Uranie


// Function defined to generate randomly a good, highly-correlated, correlation matrix for inputs
// and defibe the proper covariance with the output to do as if this output if a perfect linear combination
// of the inputs
TMatrixD GenCorr(int _nX=8, bool correlated=true)
{

    gRandom->SetSeed(__rdtsc());
    //Define a randomly filled matrix 
    TMatrixD A(_nX,_nX);
    for (int i=0; i<_nX; i++)
        for (int j=0; j<_nX; j++)
            A(i,j)=gRandom->Gaus(0,1);

    // Compute AA^T and normalise it to get "covariance matrix"
    TMatrixD Gamma(A,TMatrixD::kMultTranspose,A);
    Gamma*=1./_nX;

    // Get the inverse of the diagonal matrix to do as if this was 1/sqrt(variance)
    TMatrixD Sig(_nX,_nX);
    for(int i=0;i<_nX;i++) Sig(i,i)=1./sqrt( Gamma(i,i) );

    // Compute the input correlation matrix 
    TMatrixD inCorr(Sig*Gamma,TMatrixD::kMult, Sig);
    if( !correlated )
        inCorr.UnitMatrix();
    double varY=inCorr.Sum();

    // Proper correlation, output included
    TMatrixD Corr(_nX+1,_nX+1);
    Corr.UnitMatrix();
    // putting already defined input
    Corr.SetSub(0,0,inCorr);
    // Adjust the covariance of the output wrt to all inputs
    for(unsigned int i=0; i<_nX; i++)
    {
        double value=0;
        for(unsigned int j=0; j<_nX; j++)
            value+=inCorr(i,j);
        Corr(_nX,i) = Corr(i,_nX) = value / sqrt(varY);
    }
        
    return Corr;
}


void sensitivityJohnsonRWJustCorrelationFakeFlowrate()
{      
  // Define the DataServer
  TDataServer *tds = new TDataServer("tdsflowrate", "DataBase flowrate");
  tds->addAttribute("rw");
  tds->addAttribute("r");
  tds->addAttribute("tu");
  tds->addAttribute("tl");
  tds->addAttribute("hu");
  tds->addAttribute("hl");
  tds->addAttribute("l");
  tds->addAttribute("kw");
  // outputs
  tds->addAttribute("flowrateModel");
  tds->getAttribute("flowrateModel")->setOutput();
  

  // Get the full correlation matrix
  TMatrixD inCorr=GenCorr(8,true);

  // Johnson definition  
  TJohnsonRW * tjrw = new TJohnsonRW(tds, "rw:r:tu:tl:hu:hl:l:kw", "flowrateModel");
  //Putting the newly defined correlation that states our output as a perfect linear combination of inputs
  tjrw->setCorrelationMatrix(inCorr);
  tjrw->computeIndexes();

  // Get the results on screen 
  tjrw->getResultTuple()->Scan("Out:Inp:Method:Value","Order==\"First\"");

  // Get the results as plots
  TCanvas *cc = new TCanvas("canhist", "histgramme");
  tjrw->drawIndexes("Flowrate", "", "nonewcanv,hist,first"); 
  cc->Print("appliUranieFakeFlowrateJohnsonRWCorrelationHistogram.png"); 

  TCanvas *ccc = new TCanvas("canpie", "TPie");
  tjrw->drawIndexes("Flowrate", "", "nonewcanv,pie"); 
  ccc->Print("appliUranieFakeFlowrateJohnsonRWCorrelationPie.png"); 
  
}

The first function, called GenCorr, is not discussed, because it is really technical and not really interesting here. The only thing to know is that it provides a proper correlation matrix: a positive-definite symmetrical matrix for the input and it computes the covariance for a "fake" output that would be a perfect linear combination of all the inputs.

Because of this, the function flowrateModel is not loaded anymore and the definition of the attributes is not the same: it is not necessary to use TStochasticAttribute because no data are generated here:

// Define the DataServer
TDataServer *tds = new TDataServer("tdsflowrate", "DataBase flowrate");
tds->addAttribute("rw");
tds->addAttribute("r");
tds->addAttribute("tu");
tds->addAttribute("tl");
tds->addAttribute("hu");
tds->addAttribute("hl");
tds->addAttribute("l");
tds->addAttribute("kw");
// outputs
tds->addAttribute("flowrateModel");
tds->getAttribute("flowrateModel")->setOutput(); 

Compared to the discussion in Section XIV.5.17.2, the only differences are the instantiation of the TJohnsonRW object and the method code to provide the correlation matrix.

// Get the full correlation matrix
TMatrixD inCorr=GenCorr(8,true);
// Johnson definition
TJohnsonRW * tjrw = new TJohnsonRW(tds, "rw:r:tu:tl:hu:hl:l:kw", "flowrateModel");
//Putting the newly defined correlation that states our output as a perfect linear combination of inputs
tjrw->setCorrelationMatrix(inCorr);

The method called to provide the correlation matrix is setCorrelationMatrix and it means that the user give a full correlation matrix (input and output variables), on the contrary to the one used in Section XIV.5.17.2 which is setInputCorrelationMatrix, which set only the input correlation matrix.

The computation of sensitivity indices can finally be done:

trbd->computeIndexes();

The rest is very common to all sensitivity macros discussed here: it will produce two plots (the first one being a histogram show below) and the console is also shown below for completness.

XIV.5.18.3. Graph

Figure XIV.60. Graph of the macro "sensitivityJohnsonRWJustCorrelationFakeFlowrate.C"

Graph of the macro "sensitivityJohnsonRWJustCorrelationFakeFlowrate.C"

XIV.5.18.4. Console

Processing sensitivityJohnsonRWJustCorrelationFakeFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[2020]
 <URANIE::WARNING> TDataServer::getNPatterns[tdsflowrate] WARNING
 <URANIE::WARNING>  The TTree is NULL
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/meTIER/sensitivity/souRCE/TSensitivity.cxx] Line[165]
 <URANIE::WARNING> TSensitivity::constructor   ERROR The TTree is empty [] 
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
 <URANIE::WARNING> 
 <URANIE::WARNING> *** URANIE WARNING ***
 <URANIE::WARNING> *** File[${SOURCEDIR}/dataSERVER/souRCE/TDataServer.cxx] Line[8099]
 <URANIE::WARNING> TDataServer::getTuple Error : There is no tree!
 <URANIE::WARNING> *** END of URANIE WARNING ***
 <URANIE::WARNING> 
************************************************************
*    Row   *       Out *       Inp *    Method *     Value *
************************************************************
*        0 * flowrateM *        rw * JohnsonRW * 0.2844573 *
*        2 * flowrateM *         r * JohnsonRW * 0.1600467 *
*        4 * flowrateM *        tu * JohnsonRW * 0.2004196 *
*        6 * flowrateM *        tl * JohnsonRW * 0.0512434 *
*        8 * flowrateM *        hu * JohnsonRW * 0.0446220 *
*       10 * flowrateM *        hl * JohnsonRW * 0.1295644 *
*       12 * flowrateM *         l * JohnsonRW * 0.0333889 *
*       14 * flowrateM *        kw * JohnsonRW * 0.0962574 *
*       16 * flowrateM *    __R2__ * JohnsonRW *         1 *
************************************************************
==> 9 selected entries

XIV.5.19. Macro "sensitivityHSICFunctionFlowrate.C"

XIV.5.19.1. Objective

The objective of this macro is to perform a sensitivity analysis using the HSIC method on a set of eight parameters used in the flowrateModel model described in Section IV.1.2.1.

XIV.5.19.2. Macro Uranie

void sensitivityHSICFunctionFlowrate(){

gROOT->LoadMacro("UserFunctions.C");

// Define the DataServer
TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
  
// Generation of the sample (it can be a given sample).
Int_t nS = 500;
TSampling *sampling = new TSampling(tds, "lhs", nS);
sampling->generateSample();	
  
TLauncherFunction * tlf = new TLauncherFunction(tds, "flowrateModel");
tlf->setDrawProgressBar(kFALSE);
tlf->run();

// Create a THSIC object, compute indexes and print results
THSIC * thsic = new THSIC(tds, "rw:r:tu:tl:hu:hl:l:kw","flowrateModel");
thsic->computeIndexes("quiet");
thsic->getResultTuple()->SetScanField(60);
thsic->getResultTuple()->Scan("Out:Inp:Method:Order:Value:CILower:CIUpper");

// Print HSIC indexes
TCanvas  *can = new TCanvas("c1", "Graph for the Macro sensitivityHSICFunctionFlowrate",5,64,1270,667);
thsic->drawIndexes("Flowrate", "", "hist,first,nonewcanv");  
 
}

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval

// Define the DataServer
TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

HSIC does not need a specific DOE, it works with a given sample. We generate a sample with TSampling and we evaluate it using TLauncherFunction

   
Int_t nS = 500;
TSampling *sampling = new TSampling(tds, "lhs", nS);
sampling->generateSample();	
  
TLauncherFunction * tlf = new TLauncherFunction(tds, "flowrateModel");
tlf->setDrawProgressBar(kFALSE);
tlf->run();
      

To instantiate the THSIC object, one uses the TDataServer,the name of the input and output variables:

THSIC * thsic = new THSIC(tds, "rw:r:tu:tl:hu:hl:l:kw","flowrateModel");

Computation of sensitivity indexes:

thsic->computeIndexes();

It will produce one plots containing the HSIC indexes and the p-value to test the Independance between inputs and outputs.The console is also shown below for completness.

XIV.5.19.3. Graph

Figure XIV.61. Graph of the macro "sensitivityHSICFunctionFlowrate.C"

Graph of the macro "sensitivityHSICFunctionFlowrate.C"

XIV.5.19.4. Console

Processing sensitivityHSICFunctionFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

*************************************************************************************
*    Row   *    Out *      Inp * Metho *     Order *    Value *  CILower *  CIUpper *
*************************************************************************************
*        0 * flowra *       rw *  HSic *    R2HSic * 0.804431 *       -1 *       -1 *
*        1 * flowra *       rw *  HSic *      HSic * 0.072723 * 0.071620 * 0.073826 *
*        2 * flowra *       rw *  HSic *   pValues * 6.8e-106 *       -1 *       -1 *
*        3 * flowra *        r *  HSic *    R2HSic * 0.002238 *       -1 *       -1 *
*        4 * flowra *        r *  HSic *      HSic * 0.000202 * -0.00090 * 0.001305 *
*        5 * flowra *        r *  HSic *   pValues * 0.712174 *       -1 *       -1 *
*        6 * flowra *       tu *  HSic *    R2HSic * 0.002528 *       -1 *       -1 *
*        7 * flowra *       tu *  HSic *      HSic * 0.000228 * -0.00087 * 0.001331 *
*        8 * flowra *       tu *  HSic *   pValues * 0.662668 *       -1 *       -1 *
*        9 * flowra *       tl *  HSic *    R2HSic * 0.003806 *       -1 *       -1 *
*       10 * flowra *       tl *  HSic *      HSic * 0.000344 * -0.00075 * 0.001447 *
*       11 * flowra *       tl *  HSic *   pValues * 0.449068 *       -1 *       -1 *
*       12 * flowra *       hu *  HSic *    R2HSic * 0.025554 *       -1 *       -1 *
*       13 * flowra *       hu *  HSic *      HSic * 0.002309 * 0.001206 * 0.003412 *
*       14 * flowra *       hu *  HSic *   pValues * 3.13e-05 *       -1 *       -1 *
*       15 * flowra *       hl *  HSic *    R2HSic * 0.020243 *       -1 *       -1 *
*       16 * flowra *       hl *  HSic *      HSic * 0.001829 * 0.000726 * 0.002932 *
*       17 * flowra *       hl *  HSic *   pValues * 0.000445 *       -1 *       -1 *
*       18 * flowra *        l *  HSic *    R2HSic * 0.024934 *       -1 *       -1 *
*       19 * flowra *        l *  HSic *      HSic * 0.002253 * 0.001150 * 0.003356 *
*       20 * flowra *        l *  HSic *   pValues * 5.64e-05 *       -1 *       -1 *
*       21 * flowra *       kw *  HSic *    R2HSic * 0.010567 *       -1 *       -1 *
*       22 * flowra *       kw *  HSic *      HSic * 0.000955 * -0.00014 * 0.002058 *
*       23 * flowra *       kw *  HSic *   pValues * 0.032459 *       -1 *       -1 *
*************************************************************************************

XIV.5.20. Macro "sensitivitySobolRankFunctionFlowrate.C"

XIV.5.20.1. Objective

The objective of this macro is to perform a sensitivity analysis using the SobolRank method on a set of eight parameters used in the flowrateModel model described in Section IV.1.2.1.

XIV.5.20.2. Macro Uranie

void sensitivitySobolRankFunctionFlowrate(){

gROOT->LoadMacro("UserFunctions.C");

// Define the DataServer
TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));
  
// Generation of the sample (it can be a given sample).
Int_t nS = 500;
TSampling *sampling = new TSampling(tds, "lhs", nS);
sampling->generateSample();	
  
TLauncherFunction * tlf = new TLauncherFunction(tds, "flowrateModel");
tlf->setDrawProgressBar(kFALSE);
tlf->run();

// Create a TSobolRank object, compute indexes and print results
TSobolRank * tsobolrank = new TSobolRank(tds, "rw:r:tu:tl:hu:hl:l:kw","flowrateModel");
tsobolrank->computeIndexes("quiet");
tsobolrank->getResultTuple()->SetScanField(60);
tsobolrank->getResultTuple()->Scan("Out:Inp:Method:Order:Value:CILower:CIUpper");

// Print Sobol indexes
TCanvas  *can = new TCanvas("c1", "Graph for the Macro sensitivitySobolRankFunctionFlowrate",5,64,1270,667);
tsobolrank->drawIndexes("Flowrate", "", "hist,first,nonewcanv");  
 
}

The function flowrateModel is loaded from the macro UserFunctions.C (the file can be found in ${URANIESYS}/share/uranie/macros)

gROOT->LoadMacro("UserFunctions.C");

Each parameter is related to the TDataServer as a TAttribute and obeys an uniform law on specific interval

// Define the DataServer
TDataServer *tds = new TDataServer("tdsflowreate", "DataBase flowreate");
tds->addAttribute( new TUniformDistribution("rw", 0.05, 0.15));
tds->addAttribute( new TUniformDistribution("r", 100.0, 50000.0));
tds->addAttribute( new TUniformDistribution("tu", 63070.0, 115600.0));
tds->addAttribute( new TUniformDistribution("tl", 63.1, 116.0));
tds->addAttribute( new TUniformDistribution("hu", 990.0, 1110.0));
tds->addAttribute( new TUniformDistribution("hl", 700.0, 820.0));
tds->addAttribute( new TUniformDistribution("l", 1120.0, 1680.0));
tds->addAttribute( new TUniformDistribution("kw", 9855.0, 12045.0));

SobolRank does not need a specific DOE, it works with a given sample. We generate a sample with TSampling and we evaluate it using TLauncherFunction

   
Int_t nS = 500;
TSampling *sampling = new TSampling(tds, "lhs", nS);
sampling->generateSample();	
  
TLauncherFunction * tlf = new TLauncherFunction(tds, "flowrateModel");
tlf->setDrawProgressBar(kFALSE);
tlf->run();
      

To instantiate the TSobolRank object, one uses the TDataServer,the name of the input and output variables:

TSobolRank * tsobolrank = new TSobolRank(tds, "rw:r:tu:tl:hu:hl:l:kw","flowrateModel");

Computation of sensitivity indexes:

tsobolrank->computeIndexes();

It will produce one plots containing the HSIC indexes and the p-value to test the Independance between inputs and outputs.The console is also shown below for completness.

XIV.5.20.3. Graph

Figure XIV.62. Graph of the macro "sensitivitySobolRankFunctionFlowrate.C"

Graph of the macro "sensitivitySobolRankFunctionFlowrate.C"

XIV.5.20.4. Console

Processing sensitivitySobolRankFunctionFlowrate.C...

--- Uranie v0.0/0 --- Developed with ROOT (6.32.02)
                      Copyright (C) 2013-2024 CEA/DES 
                      Contact: support-uranie@cea.fr 
                      Date: Tue Jan 09, 2024

*************************************************************************************
*    Row   *    Out *      Inp * Metho *     Order *    Value *  CILower *  CIUpper *
*************************************************************************************
*        0 * flowra *       rw * Sobol *     First * 0.816872 *       -1 *       -1 *
*        1 * flowra *        r * Sobol *     First * -0.04759 *       -1 *       -1 *
*        2 * flowra *       tu * Sobol *     First * -0.04164 *       -1 *       -1 *
*        3 * flowra *       tl * Sobol *     First * -0.00414 *       -1 *       -1 *
*        4 * flowra *       hu * Sobol *     First * 0.041272 *       -1 *       -1 *
*        5 * flowra *       hl * Sobol *     First * 0.036748 *       -1 *       -1 *
*        6 * flowra *        l * Sobol *     First * 0.062867 *       -1 *       -1 *
*        7 * flowra *       kw * Sobol *     First * 0.021273 *       -1 *       -1 *
*************************************************************************************
/language/en