Documentation / User's manual in C++ :

The constructor prototype used with an analytic function is:

// Create a TFiniteDifferences object with an analytic function
TFiniteDifferences(TDataServer *tds, const char *fcn, TString sensitiveAtt, TString outputAtt, TString samplingOption="steps=1%")
TFiniteDifferences(TDataServer *tds, void * fcn(double *,double *), TString sensitiveAtt, TString outputAtt, TString samplingOption="steps=1%")

This constructor takes five arguments:

The options available are the options of the method Sampler::TOATSampling . They are written as strings of the form:"steps=x", where "x" can either be a real value (e.g. "steps=3.1415") or a percentage of the nominal value (e.g. "steps=0.123%"). This "steps" value is the same for each input parameter.

Here is an example of how to use the constructor with an analytic function:

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

The constructor prototype used with a code is:

// Create a TFiniteDifferences object with a code
TFiniteDifferences(TDataServer *tds, TCode *fcode,  TString sensitiveAtt="", TString samplingOption="steps=1%")

This constructor takes four arguments:

The options available are the options of the method Sampler::TOATSampling. It's a string of the form:"steps=x", where "x" can either be a real value (e.g. "steps=3.1415") or a percentage of the nominal value (e.g. "steps=0.123%"). This "steps" value is the same for each input parameter.

Here is an example of the use of this constructor on the flowrate case:

// The reference input file
TString sJDDReference = TString("flowrate_input_with_keys.in");

// Set the reference input file and the key for each input attributes
tds->getAttribute("rw")->setFileKey(sJDDReference, "Rw");
tds->getAttribute("r")->setFileKey(sJDDReference, "R");
tds->getAttribute("tu")->setFileKey(sJDDReference, "Tu");
tds->getAttribute("tl")->setFileKey(sJDDReference, "Tl");
tds->getAttribute("hu")->setFileKey(sJDDReference, "Hu");
tds->getAttribute("hl")->setFileKey(sJDDReference, "Hl");
tds->getAttribute("l")->setFileKey(sJDDReference, "L");
tds->getAttribute("kw")->setFileKey(sJDDReference, "Kw");

// The output file of the code
TOutputFileRow *fout = new TOutputFileRow("_output_flowrate_withRow_.dat");
// The attribute in the output file
fout->addAttribute(new TAttribute("yhat"));

// Instanciation de mon code
TCode *mycode = new TCode(tds, "flowrate -s -k");
// Adding the outputfile to the tcode object
mycode->addOutputFile( fout );

TFiniteDifferences * tfindefC = new TFiniteDifferences(tds,mycode);

The constructor prototype used with a code is:

// Create a TFiniteDifferences object with a runner
TFiniteDifferences(TDataServer *tds, TRun *run,  TString sensitiveAtt="", TString samplingOption="steps=1%")

This constructor takes four arguments:

The options available are the options of the method Sampler::TOATSampling. It's a string of the form:"steps=x", where "x" can either be a real value (e.g. "steps=3.1415") or a percentage of the nominal value (e.g. "steps=0.123%"). This "steps" value is the same for each input parameter.

Here is an example of the use of this constructor on the flowrate case, using the code:

// The input file
TKeyScript infile("flowrate_input_with_keys.in");
// provide the input and their key
infile.setInputs(8, tds->getAttribute("rw"), "Rw", tds->getAttribute("r"), "R",
tds->getAttribute("tu"), "Tu", tds->getAttribute("tl"), "Tl", tds->getAttribute("hu"), "Hu",
tds->getAttribute("hl"), "Hl", tds->getAttribute("l"), "L", tds->getAttribute("kw"), "Kw");

TAttribute yhat("yhat");
// The output file of the code
TKeyResult outfile("_output_flowrate_withKey_.dat");
// The attribute in the output file
outfile.addOutput(&yhat, "yhat");

// Instanciation de mon code
TCodeEval code("flowrate -s -k");
// Adding the intput/output file to the code
code.addInputFile(&infile);
code.addOutputFile(&outfile);

TSequentialRun run(&code);
run.startSlave();
if(run.onMaster())
{
   TFiniteDifferences * tfindefR = new TFiniteDifferences(tds, &run);
   // ....
}

The two constructors before are used for cases where the computation of the model outputs are run from Uranie. However it is possible to compute the outputs of the model outside of Uranie then load them in a TDataServer object (via a file) and use that TDataServer object to compute the finite difference indices.

Be aware that in that case, because of the use of internal variables, it is necessary to use a sample of input parameters computed with Uranie, exported in a file and then completed with the outputs of the model.

The constructor prototype used with a TDataServer object already containing the simulations is:

 //  Create a TFiniteDifferences object with already filled TDS
TFiniteDifferences(TDataServer *tds,  TString inputAtt, TString outputAtt, TString sensitiveAtt=TString(""))

This constructor takes four arguments:

Below is an example of the constructor with a TDataServer object filled:

// Define the DataServer  and add the attributes
TDataServer *tdsFilled = new TDataServer();
tdsFilled->fileDataRead("sampleFiniteDifferencesFlowrateModel.dat");
tdsFilled->getAttribute("flowrateModel")->setOutput(); // Mark the output

TFiniteDifferences * tfindef2 = new TFiniteDifferences(tdsFilled, TString("rw:r:tu:tl:hu:hl:l:kw"), TString("flowrateModel"));