Changeset 984

Show
Ignore:
Timestamp:
10/24/08 22:20:33 (2 months ago)
Author:
dutfoy
Message:

Added a new guide that provides full-length studies, the Examples guide.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/dutfoy/devel/doc/src/DocumentationGuide/OpenTURNS_DocumentationGuide.tex

    r977 r984  
    7575\begin{itemize} 
    7676   \item[$\bullet$] {\itshape Open TURNS - Reference Guide}, 
    77   \item[$\bullet$] {\itshape Open TURNS - Example Guide} (to appear soon). 
     77  \item[$\bullet$] {\itshape Open TURNS - Example Guide}. 
    7878\end{itemize} 
    7979 
    …… 
    101101This Guide applies the whole Global Methodology on the following analytical example :  the evaluation of the height of an embankment to protect from flows.\\ 
    102102 
    103 The User may find in this documentation a complete probabilistic uncertainty treatment study. In particular, all the results are discussed and the documentation aims at explicitating the interest of such a study. \\ 
    104 Let's note that the documentation {\itshape Open TURNS - Use Cases Guide for the Textual User Interface} gives also the example of an uncertainty study, performed on the analytical example of a cantilever beam wich undergoes a concentrated bending force at one end.\\ 
     103The User may find in this documentation a complete probabilistic uncertainty treatment study.\\ 
     104The first example is performed on the analytical example of a cantilever beam wich undergoes a concentrated bending force at one end.\\ 
    105105 
    106106The User is invited to refer to that documentation in particular to apprehend properly the signification of the results of the methods preconised in the Globel Methodology.\\ 
    …… 
    201201\item {\itshape Reference Guide} : \\ 
    202202source file $OpenTURNS\_ReferenceGuide.tex$, 
    203 %\item {\itshape Example Guide} : \\ 
    204 %source file $OpenTURNS\_ExampleGuide.tex$. 
     203\item {\itshape Example Guide} : \\ 
     204source file $OpenTURNS\_ExampleGuide.tex$. 
    205205\end{itemize} 
    206206  \item[$\bullet$] {\bf TextualUserInterface} :  

  • branches/dutfoy/devel/doc/src/ExampleGuide/Makefile.am

    r977 r984  
    2828        OpenTURNS_ExampleGuide.tex \ 
    2929        poutre.pdf \ 
    30         Math_Notations.sty 
     30        convergenceGrapheDS.pdf\ 
     31        convergenceGrapheIS.pdf \ 
     32        convergenceGrapheLHS.pdf \ 
     33        convergenceGrapheMonteCarlo.pdf \ 
     34        distributionE_pdf.pdf \ 
     35        distributionF_pdf.pdf \ 
     36        distributionI_pdf.pdf \ 
     37        distributionL_pdf.pdf \ 
     38        ImportanceFactorsDrawingFORM.pdf \ 
     39        smoothedCDF.pdf\ 
     40        smoothedPDF.pdf\ 
     41        smoothedPDF_and_GaussianPDF.pdf \ 
     42        Math_Notations.sty\ 
     43        scriptExample_beam.py 
    3144 
    3245OpenTURNS_ExampleGuide.pdf : $(EXTRA_DIST) 
     46 
    3347pdf-local : OpenTURNS_ExampleGuide.pdf 
    3448doc_DATA = OpenTURNS_ExampleGuide.pdf 

  • branches/dutfoy/devel/doc/src/ExampleGuide/OpenTURNS_ExampleGuide.tex

    r977 r984  
    1 %Copyright (c)  2007  EDF-EADS-PHIMECA. 
     1 
     2%Copyright (c)  2005  EDF-EADS-PHIMECA. 
    23%  Permission is granted to copy, distribute and/or modify this document 
    34%  under the terms of the GNU Free Documentation License, Version 1.2 
    …… 
    7374\pagestyle{fancy} 
    7475\fancyhf{} \rhead{\bfseries \thepage} \lhead{\bfseries \nouppercase Open TURNS -- Example Guide} 
    75 \rfoot{\bfseries \copyright 2007 EDF - EADS - PhiMeca} \lfoot{} 
     76\rfoot{\bfseries \copyright 2005 EDF - EADS - PhiMeca} \lfoot{} 
    7677 
    7778\makeindex 
    …… 
    8283\vspace*{2cm} 
    8384\begin{center} 
    84 {\huge \bf Example Guide} 
     85{\huge \bf Examples Guide} 
    8586\input{GenericInformation.tex} 
    8687\end{center} 
    …… 
    9394% ------------------------------------------------------------------------------------------------- 
    9495\newpage 
    95 \section{Annexe 1 :  Presentatio of the example case} 
     96\section{Example 1 : deviation of a cantilever beam} 
    9697 
    9798\subsection{Presentation of the study case} 
    …… 
    120121 
    121122 
    122 The objective of this studyis to evaluate the influence of uncertainties on the input data $(E, F, L, I)$ on the deviation $y$.\\ 
    123  
    124 We consider a steel beam with a hollow square section of length $a = 2. e-2 m$ and of thickness $t=1.e-3 m$. Thus, the flexion section inertie of the beam is equal to $I = 2.47e-9 m^4$. The beam length is $L = 1 m$. The Young's modulus $E$ is $E = 2.1e11 kg.m^{-1}.s^{-2}$. The charge applied is $F = 10 kg.m.s^{-2}$.\\ 
    125 The random modelisation of the input data is the following one : we consider for each input data a gaussian distribution, which mean $\mu$ is the deterministic value given above and which standard deviation is a percentile of the mean :  
    126 \begin{itemize} 
    127   \item[$\bullet$] E  = Gaussian($\mu_E$, 5\% * $\mu_E$)  
    128   \item[$\bullet$] F  = Gaussian($\mu_F$, 10\% * $\mu_F$) 
    129   \item[$\bullet$] L  = Gaussian($\mu_L$, 1\% * $\mu_L$) 
    130   \item[$\bullet$] I  = Gaussian($\mu_I$, 1\% * $\mu_I$) 
    131 \end{itemize} 
    132 \vspace*{0.5cm} 
     123The objective of this study is to evaluate the influence of uncertainties of the input data $(E, F, L, I)$ on the deviation $y$.\\ 
     124 
     125We consider a steel beam with a hollow square section of length $a$ and of thickness $e$. Thus, the flexion section inertie of the beam is equal to $I = \displaystyle \frac{a^4 - (a-e)^4}{12}$. The beam length is $L$. The Young's modulus is $E$. The charge applied is $F$.\\ 
     126 
     127The  values used for the deterministic studies are :  
     128$$ 
     129\left\{ 
     130\begin{array}{lcl} 
     131 E & = & 3.0e9 Pa\\ 
     132 F & = & 300 N\\ 
     133 L & = & 2.5m\\ 
     134 I & = & 4.0e-6 m^4. 
     135\end{array} 
     136\right. 
     137$$ 
     138which corresponds to the point $(3.0e7, 30000, 250, 400)$ when the lenght $L$ is given in unit $cm$ et noo in the standard unit $m$.\\ 
     139 
     140 
    133141This example treats the following points of the methodology :  
    134142\begin{itemize} 
    135   \item[$\bullet$] Deterministic Study : Min/Max study 
     143  \item[$\bullet$] Min/Max approach : evaluation of the range of the output variable of interest (deviation) 
    136144\begin{itemize} 
    137145  \item with a deterministic experiment plane, 
    138146  \item with a random experiment plane, 
    139147\end{itemize} 
    140   \item[$\bullet$] Random Study : central tendance of the output variable of interest 
     148  \item[$\bullet$] Central tendancy approach : evaluation of the central indicators of the output variable of interest (deviation) 
    141149\begin{itemize} 
    142150  \item Taylor variance decomposition, 
    143151  \item Random sampling, 
    144   \item kernel fitting of the distribution of the output variable of interest, 
    145 \end{itemize} 
    146   \item[$\bullet$] Random Study : threshold exceedance: deviation <-1cm 
     152  \item Kernel smoothing of the distribution of the output variable of interest, 
     153\end{itemize} 
     154  \item[$\bullet$] Threshold exceedance approach : evaluation of the probability that the output variable of interest (deviation) 30$\geq 30cm$ 
    147155\begin{itemize} 
    148156  \item FORM, 
    149   \item SORM, 
    150   \item Monte Carlo simulation method, 
    151   \item Directional Sampling method, 
    152   \item Latin HyperCube Sampling method, 
    153   \item Importance Sampling method, 
    154 \end{itemize} 
    155 \end{itemize} 
    156  
    157  
    158  
    159 \subsection{The TUI File} 
    160  
    161  
    162 \begin{lstlisting} 
    163 #! /usr/bin/env python 
    164  
    165 from openturns import * 
    166  
    167 from math import * 
    168  
    169 from openturns_viewer import ViewImage 
    170  
    171 # This function enables a pretty print of a NumericalPoint 
    172 def printNumericalPoint(point, digits) : 
    173   oss = "[" 
    174   eps = pow(0.1, digits) 
    175   for i in range(point.getDimension()) : 
    176     if i == 0 : 
    177       sep = "" 
    178     else : 
    179       sep = "," 
    180     if fabs(point[i]) < eps : 
    181       oss += sep + str(fabs(point[i])) 
    182     else : 
    183       oss += sep + str(point[i]) 
    184     sep = "," 
    185   oss += "]"  
    186   return oss 
    187  
    188  
    189 ########################################### 
    190 ### Fonction 'poutre' 
    191 ########################################### 
    192  
    193 # We create a numerical math function  
    194 myFunction = NumericalMathFunction("poutre") 
    195  
    196  
    197 ########################################### 
    198 ### Random input vector 
    199 ########################################### 
    200  
    201  
    202  
    203 dim = myFunction.getInputNumericalPointDimension() 
    204  
    205 # We create a normal distribution point of dimension 4 
    206 mean = NumericalPoint(dim, 0.0) 
    207 # E : steel : 210000 MPa 
    208 mean[0] = 2.1e11 
    209 # F : 1kg : 10N 
    210 mean[1] =  10.0 
    211 # L : 1 m 
    212 mean[2] = 1.0 
    213 # I : square hollow section of width 2 cm and thickness 1mm : 2.47325 e-9 
    214 mean[3] =  2.47325e-9 
    215 sigma = NumericalPoint(dim, 1.0) 
    216 # E : 5% * mean 
    217 sigma[0] = 0.05 *  mean[0] 
    218 # F : 10% * mean 
    219 sigma[1] = 0.1 * mean[1] 
    220 # L : 1% * mean 
    221 sigma[2] = 0.01 * mean[2] 
    222 # I : 1% * mean 
    223 sigma[3] = 0.01 * mean[3] 
    224  
    225 R = IdentityMatrix(dim) 
    226 myDistribution = Normal(mean, sigma, R) 
    227  
    228  
    229 input = RandomVector(myDistribution) 
    230  
    231 output =  RandomVector(myFunction, input) 
    232  
    233  
    234 ########################################### 
    235 ### Deterministic Study 
    236 ########################################### 
    237  
    238  
    239 print "####################" 
    240 print " Deterministic Study" 
    241 print "####################" 
    242  
    243 print "deterministic evaluation at the mean point : " 
    244 print "deviation(mean point) = ", myFunction(mean) 
    245  
    246  
    247 #################################################### 
    248 # Min/Max study with deterministic experiment plane 
    249 #################################################### 
    250  
    251 print "###################################################" 
    252 print " Min/Max study with deterministic experiment plane" 
    253 print "###################################################" 
    254  
    255  
    256 # Creation of the structure of the experiment plane : type Axial  
    257  
    258 # On each direction separately, several levels are evaluated 
    259 # here,  3 levels : +/-1, +/-3, +/-5 from the center 
    260 levelsNumber = 3 
    261 levels = NumericalPoint(levelsNumber, 0.0) 
    262 levels[0] = 1 
    263 levels[1] = 3 
    264 levels[2] = 5 
    265 # Creation of the axial plane 
    266 myPlane = Axial(dim, levels) 
    267 print "myPlane = " , myPlane 
    268  
    269 # Generation of points according to the structure of the experiment plane  
    270 # (in a reduced centered space)  
    271 inputSample = myPlane.generate() 
    272  
    273 # Scaling of the structure of the experiment plane 
    274 # scaling vector for each dimension of the levels of the structure  
    275 # to take into account the dimension of each component 
    276 # for example : the standard deviation of each component of 'input'  
    277 # in case of a RandomVector 
    278 scaling = NumericalPoint(dim) 
    279 scaling[0] = sqrt(input.getCovariance()[0,0]) 
    280 scaling[1] = sqrt(input.getCovariance()[1,1]) 
    281 scaling[2] = sqrt(input.getCovariance()[2,2]) 
    282 scaling[3] = sqrt(input.getCovariance()[3,3]) 
    283 print "sigma = ", scaling 
    284 inputSample.scale(scaling) 
    285 print "centered Sample = ", inputSample 
    286  
    287 # Translation of the nonReducedSample onto the center of the experiment plane 
    288 # center = mean point of the input distribution 
    289 center = input.getMean() 
    290 inputSample.translate(center) 
    291 print "inputSample = ", inputSample 
    292 pointNumber = inputSample.getSize() 
    293 print "points number = ", pointNumber 
    294  
    295 outputSample = myFunction(inputSample) 
    296  
    297 minValue = outputSample.getMin() 
    298 maxValue = outputSample.getMax() 
    299  
    300 print " From an axial  experiment plane of size = ", pointNumber 
    301 print "levels = ", levels 
    302 print "min Value = ", minValue[0] 
    303 print "max Value = ", maxValue[0] 
    304 print "" 
    305  
    306 ########################################################### 
    307 # Min/Max study with random experiment plane 
    308 ########################################################### 
    309  
    310  
    311  
    312 print "###################################################" 
    313 print " Min/Max study with random experiment plane" 
    314 print "###################################################" 
    315  
    316 pointNumber = 100 
    317 print " From a stochastic experiment place of size = ", pointNumber 
    318 outputSample2 = output.getNumericalSample(pointNumber) 
    319  
    320 minValue2 = outputSample2.getMin() 
    321 maxValue2 = outputSample2.getMax() 
    322  
    323 print "min Value = ", minValue2[0] 
    324 print "max Value = ", maxValue2[0] 
    325 print "" 
    326  
    327 ############################################### 
    328 ### Random Study : central tendance of  
    329 ### the output variable of interest 
    330 ############################################### 
    331  
    332  
    333  
    334 print "###########################################" 
    335 print " Random Study : central tendance of" 
    336 print " the output variable of interest" 
    337 print "###########################################" 
    338  
    339 ##################################### 
    340 # Taylor variance decomposition 
    341 ##################################### 
    342  
    343 print "##############################" 
    344 print "Taylor variance decomposition" 
    345 print "##############################" 
    346  
    347 # We create a quadraticCumul algorithm 
    348 myQuadraticCumul = QuadraticCumul(output) 
    349  
    350 # We test the attributs here 
    351 print "myQuadraticCumul=", myQuadraticCumul 
    352  
    353 # We compute the several elements provided by the quadratic cumul algorithm 
    354 print "First order mean=", myQuadraticCumul.getMeanFirstOrder()[0] 
    355 print "Second order mean=", myQuadraticCumul.getMeanSecondOrder()[0] 
    356 print "Standard deviation=", sqrt(myQuadraticCumul.getCovariance()[0,0])  
    357  
    358 ############################# 
    359 # Random sampling 
    360 ############################# 
    361  
    362 print "#######################" 
    363 print "Random sampling" 
    364 print "#######################" 
    365  
    366 size1 = 10000 
    367 output_Sample1 = output.getNumericalSample(size1) 
    368 outputMean = output_Sample1.computeMean() 
    369 outputCovariance = output_Sample1.computeCovariance() 
    370  
    371 print "sample size = ", size1 
    372 print "mean from sample = ", outputMean[0] 
    373 print "standard deviation from sample = ", sqrt(outputCovariance[0,0]) 
    374  
    375  
    376 ########################## 
    377 # Kernel Smoothing Fitting 
    378 ########################## 
    379  
    380  
    381 print "##########################" 
    382 print "# Kernel Smoothing Fitting" 
    383 print "##########################" 
    384  
    385 # We generate a sample of the output variable 
    386 size = 1000 
    387 output_sample = output.getNumericalSample(size) 
    388  
    389 # We build the kernel smoothing distribution 
    390 kernel = KernelSmoothing() 
    391 smoothed = kernel.buildImplementation(output_sample) 
    392 print  "kernel bandwidth=" , kernel.getBandwidth() 
    393  
    394 # We draw the pdf and cdf from kernel smoothing 
    395 mean_sample = output_sample.computeMean()[0] 
    396 standardDeviation_sample = sqrt(output_sample.computeCovariance()[0,0]) 
    397 xmin = mean_sample - 4*standardDeviation_sample 
    398 xmax = mean_sample + 4*standardDeviation_sample 
    399  
    400 smoothedPDF = smoothed.drawPDF(xmin, xmax, 251) 
    401 smoothedPDF.draw("smoothedPDF") 
    402  
    403 smoothedCDF = smoothed.drawCDF(xmin, xmax, 251) 
    404 smoothedCDF.draw("smoothedCDF") 
    405  
    406 # In order to see the graph whithout creating the associated files 
    407 Show(smoothedCDF)  
    408 Show(smoothedPDF)  
    409  
    410 # Probability of myEvent : 1-smoothedCDF(threshold) 
    411 print "probability of the event after kernel smoothing = ", 1.0 - smoothed.computeCDF(NumericalPoint(1,threshold)) 
    412   
    413 # Superposition of the kernel smoothing pdf and the gaussian one  
    414 # which mean and standard deviation are those of the output_sample 
    415 meanSample = output_sample.computeMean() 
    416 standardDeviationSample = NumericalPoint(1, sqrt(output_sample.computeCovariance()[0,0])) 
    417 gaussianDist = Normal(meanSample,standardDeviationSample, CorrelationMatrix(1)) 
    418  
    419 gaussianDistPDF = gaussianDist.drawPDF(xmin, xmax, 251) 
    420 gaussianDistPDFDrawable = gaussianDistPDF.getDrawable(0) 
    421 gaussianDistPDFDrawable.setColor('red') 
    422 smoothedPDF.addDrawable(gaussianDistPDFDrawable) 
    423 smoothedPDF.draw("smoothedPDF_and_GaussianPDF") 
    424  
    425 # In order to see the graph whithout creating the associated files 
    426 Show(smoothedPDF)  
    427  
    428  
    429 ################################################################# 
    430 ### Probabilistic Study : threshold exceedance: deviation <-1cm 
    431 ################################################################# 
    432  
    433 print "############################################################" 
    434 print "Probabilistic Study : threshold exceedance: deviation <-1cm" 
    435 print "############################################################" 
    436  
    437 ###### 
    438 # FORM 
    439 ###### 
    440  
    441  
    442 print "#####" 
    443 print "FORM" 
    444 print "#####" 
    445  
    446 # We create an Event from this RandomVector 
    447 threshold = -0.01 
    448 myEvent = Event(output, ComparisonOperator(Less()), threshold) 
    449  
    450 # We create a NearestPoint algorithm  
    451 myCobyla = Cobyla() 
    452 myCobyla.setMaximumIterationsNumber(1000) 
    453 myCobyla.setMaximumAbsoluteError(1.0e-10) 
    454 myCobyla.setMaximumRelativeError(1.0e-10) 
    455 myCobyla.setMaximumResidualError(1.0e-10) 
    456 myCobyla.setMaximumConstraintError(1.0e-10) 
    457 #print  "myCobyla=", myCobyla   
    458  
    459 # We create a FORM algorithm  
    460 # The first parameter is a NearestPointAlgorithm  
    461 # The second parameter is an event  
    462 # The third parameter is a starting point for the design point research  
    463 myAlgoFORM = FORM(NearestPointAlgorithm(myCobyla), myEvent, mean) 
    464  
    465 #print  "FORM=" , myAlgo  
    466  
    467 # Perform the simulation  
    468 myAlgoFORM.run() 
    469  
    470 # Stream out the result  
    471 resultFORM = myAlgoFORM.getResult() 
    472 digits = 5 
    473 print  "FORM event probability=" , resultFORM.getEventProbability()  
    474 print  "generalized reliability index=" , resultFORM.getGeneralisedReliabilityIndex()  
    475 print  "standard space design point=" , printNumericalPoint(resultFORM.getStandardSpaceDesignPoint(), digits)  
    476 print  "physical space design point=" , printNumericalPoint(resultFORM.getPhysicalSpaceDesignPoint(), digits)  
    477  
    478 print  "importance factors=" , printNumericalPoint(resultFORM.getImportanceFactors(), digits)  
    479 print  "Hasofer reliability index=" , resultFORM.getHasoferReliabilityIndex()  
    480  
    481 # Graph 1 : Importance Factors graph */ 
    482 importanceFactorsGraph = resultFORM.drawImportanceFactors() 
    483 importanceFactorsGraph.draw("ImportanceFactorsDrawingFORM") 
    484      
    485 # View the bitmap file 
    486 ViewImage(importanceFactorsGraph.getBitmap()) 
    487  
    488 # In order to see the graph whithout creating the associated files 
    489 Show(importanceFactorsGraph)  
    490  
    491 # Graph 2 : Hasofer Reliability Index Sensitivity Graphs graph */ 
    492 reliabilityIndexSensitivityGraphs = resultFORM.drawHasoferReliabilityIndexSensitivity() 
    493 reliabilityIndexSensitivityGraphs[0].draw("HasoferReliabilityIndexMarginalSensitivityDrawing") 
    494  
    495 # In order to see the graph whithout creating the associated files 
    496 Show(reliabilityIndexSensitivityGraphs[0])  
    497      
    498 # View the bitmap file 
    499 ViewImage(reliabilityIndexSensitivityGraphs[0].getBitmap()) 
    500  
    501 # Graph 3 : FORM Event Probability Sensitivity Graphs graph */ 
    502 eventProbabilitySensitivityGraphs = resultFORM.drawEventProbabilitySensitivity() 
    503 eventProbabilitySensitivityGraphs[0].draw("EventProbabilityIndexMarginalSensitivityDrawing") 
    504  
    505 # In order to see the graph whithout creating the associated files 
    506 Show(eventProbabilitySensitivityGraphs[0])  
    507      
    508 # View the bitmap file 
    509 ViewImage(eventProbabilitySensitivityGraphs[0].getBitmap()) 
    510  
    511  
    512 ###### 
    513 # SORM 
    514 ###### 
    515  
    516  
    517 print "#####" 
    518 print "SORM" 
    519 print "#####" 
    520  
    521 # We create a SORM algorithm  
    522 myAlgoSORM = SORM(NearestPointAlgorithm(myCobyla), myEvent, mean) 
    523  
    524 # Perform the simulation  
    525 myAlgoSORM.run() 
    526  
    527 # Stream out the result  
    528 resultSORM = myAlgoSORM.getResult() 
    529 digits = 5 
    530 print  "Breitung event probability=" , resultSORM.getEventProbabilityBreitung()  
    531 print  "Breitung generalized reliability index=" , resultSORM.getGeneralisedReliabilityIndexBreitung()  
    532 print  "HohenBichler event probability=" , resultSORM.getEventProbabilityHohenBichler()  
    533 print  "HohenBichler generalized reliability index=" , resultSORM.getGeneralisedReliabilityIndexHohenBichler()  
    534 print  "Tvedt event probability=" , resultSORM.getEventProbabilityTvedt()  
    535 print  "Tvedt generalized reliability index=" , resultSORM.getGeneralisedReliabilityIndexTvedt()  
    536  
    537 ###### 
    538 # MC 
    539 ###### 
    540  
    541 print "############" 
    542 print "Monte Carlo" 
    543 print "############" 
    544  
    545  
    546 maximumOuterSampling = 400 
    547 blockSize = 100000 
    548 coefficientOfVariation = 0.10 
    549  
    550 # We create a Monte Carlo algorithm  
    551 myAlgoMonteCarlo = MonteCarlo(myEvent) 
    552 myAlgoMonteCarlo.setMaximumOuterSampling(maximumOuterSampling) 
    553 myAlgoMonteCarlo.setBlockSize(blockSize) 
    554 myAlgoMonteCarlo.setMaximumCoefficientOfVariation(coefficientOfVariation) 
    555  
    556 print  "MonteCarlo=" , myAlgoMonteCarlo  
    557  
    558 # Perform the simulation  
    559 myAlgoMonteCarlo.run() 
    560  
    561 # Stream out the result  
    562 print  "MonteCarlo result=" , myAlgoMonteCarlo.getResult() 
    563  
    564 # Display number of iterations and number of evaluations  
    565 # of the limit state function 
    566 print "external iteration numbers = " , myAlgoMonteCarlo.getResult().getOuterSampling() 
    567 print "number of evaluations of the limit state function = ", myAlgoMonteCarlo.getResult().getOuterSampling()* myAlgoMonteCarlo.getResult().getBlockSize() 
    568  
    569 # Display the Monte Carlo probability of 'myEvent' 
    570 print "Monte Carlo probability estimation = ", myAlgoMonteCarlo.getResult().getProbabilityEstimate() 
    571  
    572 # Display the variance of the Monte Carlo probability estimator 
    573 print "Variance of the Monte Carlo probability estimator = ", myAlgoMonteCarlo.getResult().getVarianceEstimate() 
    574  
    575 # Display the confidence interval length centered around 
    576 # the MonteCarlo probability MCProb 
    577 # IC = [MCProb - 0.5*length, MCProb + 0.5*length] 
    578 # level 0.95 
    579 print "0.95 Confidence Interval length = ", myAlgoMonteCarlo.getResult().getConfidenceLength(0.95) 
    580 # 
    581 print "0.95 Confidence Interval = [", myAlgoMonteCarlo.getResult().getProbabilityEstimate() - 0.5*myAlgoMonteCarlo.getResult().getConfidenceLength(0.95), ", ", myAlgoMonteCarlo.getResult().getProbabilityEstimate() + 0.5*myAlgoMonteCarlo.getResult().getConfidenceLength(0.95), "]" 
    582  
    583 ######################## 
    584 # Directional Sampling 
    585 ######################## 
    586  
    587 print "#######################" 
    588 print "Directional Sampling" 
    589 print "#######################" 
    590  
    591 # Directional sampling from an event (slow and safe strategy by default) 
    592  
    593 # We create a Directional Sampling algorithm */ 
    594 myAlgoDirectionalSim = DirectionalSampling(myEvent) 
    595 myAlgoDirectionalSim.setMaximumOuterSampling(maximumOuterSampling * blockSize) 
    596 myAlgoDirectionalSim.setBlockSize(1) 
    597 myAlgoDirectionalSim.setMaximumCoefficientOfVariation(coefficientOfVariation) 
    598  
    599 print "DirectionalSampling=", myAlgoDirectionalSim 
    600  
    601  
    602      
    603 # Save the number of calls to the limit state fucntion, its gradient and hessian already done 
    604 limitStateFunctionCallNumberBefore = limitStateFunction.getEvaluationCallsNumber() 
    605 limitStateFunctionGradientCallNumberBefore = limitStateFunction.getGradientCallsNumber() 
    606 limitStateFunctionHessianCallNumberBefore = limitStateFunction.getHessianCallsNumber() 
    607  
    608 # Perform the simulation */ 
    609 myAlgoDirectionalSim.run() 
    610      
    611 # Save the number of calls to the limit state fucntion, its gradient and hessian already done 
    612 limitStateFunctionCallNumberAfter = limitStateFunction.getEvaluationCallsNumber() 
    613 limitStateFunctionGradientCallNumberAfter = limitStateFunction.getGradientCallsNumber() 
    614 limitStateFunctionHessianCallNumberAfter = limitStateFunction.getHessianCallsNumber() 
    615  
    616 # Stream out the result */ 
    617 print "Directional Sampling result=", myAlgoDirectionalSim.getResult() 
    618  
    619 # Display number of iterations and number of evaluations  
    620 # of the limit state function 
    621 print "external iteration numbers = " , myAlgoDirectionalSim.getResult().getOuterSampling() 
    622 print "number of evaluations of the limit state function = ", limitStateFunctionCallNumberAfter - limitStateFunctionCallNumberBefore 
    623  
    624 # Display the Directional Simumation probability of 'myEvent' 
    625 print "Directional Sampling probability estimation = ", myAlgoDirectionalSim.getResult().getProbabilityEstimate() 
    626  
    627 # Display the variance of the Directional Simumation probability estimator 
    628 print "Variance of the Directional Sampling probability estimator = ", myAlgoDirectionalSim.getResult().getVarianceEstimate() 
    629  
    630 # Display the confidence interval length centered around  
    631 # the Directional Simumation probability DSProb 
    632 # IC = [DSProb - 0.5*length, DSProb + 0.5*length] 
    633 # level 0.95 
    634 print "0.95 Confidence Interval length = ", myAlgoDirectionalSim.getResult().getConfidenceLength(0.95) 
    635 print "0.95 Confidence Interval = [", myAlgoDirectionalSim.getResult().getProbabilityEstimate() - 0.5*myAlgoDirectionalSim.getResult().getConfidenceLength(0.95), ", ", myAlgoDirectionalSim.getResult().getProbabilityEstimate() + 0.5*myAlgoDirectionalSim.getResult().getConfidenceLength(0.95), "]" 
    636  
    637 ########################## 
    638 # Latin HyperCube Sampling 
    639 ########################### 
    640  
    641 print "###########################" 
    642 print "Latin HyperCube Sampling" 
    643 print "###########################" 
    644  
    645 # We create a LHS algorithm  
    646 myAlgoLHS = LHS(myEvent) 
    647 myAlgoLHS.setMaximumOuterSampling(maximumOuterSampling) 
    648 myAlgoLHS.setBlockSize(blockSize) 
    649 myAlgoLHS.setMaximumCoefficientOfVariation(coefficientOfVariation) 
    650  
    651 print  "LHS=" , myAlgoLHS  
    652  
    653 # Perform the simulation  
    654 myAlgoLHS.run() 
    655  
    656 # Stream out the result  
    657 print  "LHS result=" , myAlgoLHS.getResult() 
    658  
    659 # Display number of iterations and number of evaluations  
    660 # of the limit state function 
    661 print "external iteration numbers = " , myAlgoLHS.getResult().getOuterSampling() 
    662 print "number of evaluations of the limit state function = ", myAlgoLHS.getResult().getOuterSampling()*myAlgoLHS.getResult().getBlockSize() 
    663  
    664 # Display the LHS probability of {\itshape myEvent} 
    665 print "LHS probability estimation = ", myAlgoLHS.getResult().getProbabilityEstimate() 
    666  
    667 # Display the variance of the LHS probability estimator 
    668 print "Variance of the LHS probability estimator = ", myAlgoLHS.getResult().getVarianceEstimate() 
    669  
    670 # Display the confidence interval length centered aroung the LHS probability LHSProb 
    671 # IC = [LHSProb - 0.5*length, LHSProb + 0.5*length] 
    672 # level 0.95 
    673 print "0.95 Confidence Interval length = ", myAlgoLHS.getResult().getConfidenceLength(0.95) 
    674 print "0.95 Confidence Interval = [", myAlgoLHS.getResult().getProbabilityEstimate() - 0.5*myAlgoLHS.getResult().getConfidenceLength(0.95), ", ", myAlgoLHS.getResult().getProbabilityEstimate() + 0.5*myAlgoLHS.getResult().getConfidenceLength(0.95), "]" 
    675  
    676 ##################### 
    677 # Importance Sampling 
    678 ##################### 
    679  
    680  
    681 print "####################" 
    682 print "Importance Sampling" 
    683 print "####################" 
    684  
    685 standardSpaceDesignPoint = resultFORM.getStandardSpaceDesignPoint() 
    686 mean = standardSpaceDesignPoint 
    687 sigma = NumericalPoint(4, 1.0) 
    688 importanceDistribution = Normal(mean, sigma, CorrelationMatrix(4)) 
    689  
    690 myStandardEvent = StandardEvent(myEvent) 
    691  
    692 myAlgoImportanceSampling = ImportanceSampling(myStandardEvent, Distribution(importanceDistribution)) 
    693 myAlgoImportanceSampling.setMaximumOuterSampling(maximumOuterSampling) 
    694 myAlgoImportanceSampling.setBlockSize(blockSize) 
    695 myAlgoImportanceSampling.setMaximumCoefficientOfVariation(coefficientOfVariation) 
    696  
    697 print  "Importance Sampling=" , myAlgoImportanceSampling  
    698  
    699 # Perform the simulation  
    700 myAlgoImportanceSampling.run() 
    701  
    702 # Stream out the result  
    703 print  "Importance Sampling result=" , myAlgoImportanceSampling.getResult()  
    704  
    705 # Display number of iterations and number of evaluations  
    706 # of the limit state function 
    707 print "external iteration numbers = " , myAlgoImportanceSampling.getResult().getOuterSampling() 
    708 print "number of evaluations of the limit state function = ", myAlgoImportanceSampling.getResult().getOuterSampling()* myAlgoImportanceSampling.getResult().getBlockSize() 
    709  
    710 # Display the Importance Sampling probability of 'myEvent' 
    711 print "Importance Sampling probability estimation = ", myAlgoImportanceSampling.getResult().getProbabilityEstimate() 
    712  
    713 # Display the variance of the Importance Sampling probability estimator 
    714 print "Variance of the Importance Sampling probability estimator = ", myAlgoImportanceSampling.getResult().getVarianceEstimate() 
    715  
    716 # Display the confidence interval length centered around 
    717 # the ImportanceSampling probability ISProb 
    718 # IC = [ISProb - 0.5*length, ISProb + 0.5*length] 
    719 # level 0.95 
    720 print "0.95 Confidence Interval length = ", myAlgoImportanceSampling.getResult().getConfidenceLength(0.95) 
    721 print "0.95 Confidence Interval = [", myAlgoImportanceSampling.getResult().getProbabilityEstimate() - 0.5*myAlgoImportanceSampling.getResult().getConfidenceLength(0.95), ", ", myAlgoImportanceSampling.getResult().getProbabilityEstimate() + 0.5*myAlgoImportanceSampling.getResult().getConfidenceLength(0.95), "]" 
    722  
    723 \end{lstlisting} 
    724 \espace 
    725  
    726  
    727 \subsection{The results of the study} 
    728  
    729 mettre ici les impressions ecran + graphes + commentaires 
    730  
    731 subsubsection{Etpaes de la méthodo} 
    732  
    733  
    734  
    735  
    736  
    737  
    738  
    739 \printindex 
     157\item Monte Carlo simulation method, 
     158\item Directional Sampling method, 
     159 \item Importance Sampling method. 
     160\end{itemize} 
     161\end{itemize} 
     162 
     163 
     164\subsection{Probabilistic modelisation} 
     165 
     166\subsubsection{Marginal distributions} 
     167 
     168The random modelisation of the input data is the following one :   
     169\begin{itemize} 
     170  \item[$\bullet$] E = Beta$(*)$ where $r = O.93,t = 3.2,a = 2.8e7,b = 4.8e7$, 
     171  \item[$\bullet$] F  = LogNormal, where the mean value is $E[F] = 30000$, the standard deviation is $\sqrt{Var[F]} = 9000$ and the min value is $min(E) = 15000$, 
     172  \item[$\bullet$] L  = Uniform on $[250; 260]$, 
     173  \item[$\bullet$] I  = Beta$(*)$ where $r = 2.5,t = 4.0,a = 3.1e2,b = 4.5e2$. 
     174\end{itemize} 
     175(*) We recall here the expression of the probability density function of the Beta distribution :  
     176$$ 
     177\displaystyle  p(x) = \frac{(x-a)^{(r-1)}(b-x)^{(t-r-1)}}{(b-a)^{(t-1)}B(r,t-r)}\boldsymbol{1}_{[a,b]}(x) 
     178$$ 
     179where $r>0$, $t>r$ and $a < b$. 
     180 
     181 
     182 
     183\subsubsection{Dependence structure} 
     184 
     185We suppose that the probabilstic variables $L$ and $I$ are dependent. This dependence may be explained by the manufacturing process of the beam : the thiner the beam has been laminated, the longer it is.\\ 
     186We modelise the dependence structure by a Normal copula, parameterized from the Spearman correlation coefficient of both correlated variables : $\rho_S = -0.2$.\\ 
     187Then, the Spearman correlation matrix of the input random vector $(E,F,L,I)$ is :  
     188$$ 
     189R_S = \left ( 
     190\begin{array}{cccc} 
     191  1 & 0 & 0 & 0 \\ 
     192  0 & 1 & 0 & 0 \\ 
     193  0 & 0 & 1 & -0.2 \\ 
     194  0 & 0 & -0.2 & 1 
     195\end{array} 
     196\right) 
     197$$ 
     198 
     199 
     200 
     201 
     202 
     203\subsection{Min/Max approach} 
     204 
     205 
     206\subsubsection{Deterministic experiment plane} 
     207 
     208We consider a composite experiment plane, where :  
     209\begin{itemize} 
     210  \item the levels of the centered and reducted grid are +/-0.5, +/-1., +/-3., 
     211  \item the unit per dimension (scaling factor) is given by the standard deviation of the marginal distribution of the corresponding variable, 
     212  \item the center is the mean point of the input random vector distribution. 
     213\end{itemize} 
     214 
     215 
     216 
     217\subsubsection{Random sampling} 
     218 
     219We evaluate the range of the deviation from a random sample of size $10^4$. 
     220 
     221 
     222 
     223\subsection{Central tendancy approach} 
     224 
     225 
     226\subsubsection{Taylor variance decomposition} 
     227 
     228We evaluate the mean and the standard deviation of the deviation thanks to the Taylor variance decomposition method. The importance factors of that method rank the influence of the input uncertainties on the mean of the deviation. 
     229 
     230\subsubsection{Random sampling} 
     231 
     232We evaluate the mean and standard deviation of the deviation from a random sample of size $10^4$. 
     233 
     234\subsubsection{Kernel smoothing} 
     235 
     236We fit the distribution of the deviation with a Normal kernel, which bandwith is evaluated from the Scott rule, from a random sample of size $10^4$.\\ 
     237We superpose then the kernel smoothing pdf and the normal one which mean and standard deviation are those of the random sample of the output variable of interest in order to graphically check if the Normal model fits to the deviation distribution. 
     238 
     239\subsection{Threshold exceedance approach} 
     240 
     241We consider the event where the deviation exceeds $30 cm$.\\ 
     242 
     243\subsubsection{FORM} 
     244 
     245We use the Cobyla algorithm to research the design point, which requires no evaluation of the gradient of the limit state function. We parameterize the Cobyla algorithmwit hte following parameters :  
     246\begin{itemize} 
     247  \item Maximum Iterations Number = $10^3$, 
     248  \item Maximum Absolute Error = $10^{-10}$, 
     249  \item Maximum Relative Error = $10^{-10}$, 
     250  \item Maximum Residual Error = $10^{-10}$, 
     251  \item Maximum Constraint Error = $10^{-10}$. 
     252\end{itemize} 
     253 
     254 
     255\subsubsection{Monte Carlo simulation method} 
     256 
     257We evaluate the probability with the Monte Carlo method, parameterized as follows :  
     258\begin{itemize} 
     259  \item Maximum Outer Sampling = $4\, 10^4$, 
     260  \item Block Size = $10^2$, 
     261  \item Maximum Coefficient of Variation = $10^{-1}$. 
     262\end{itemize} 
     263 
     264We evaluate the confidence interval of level $0.95$ and we draw the convergence graph of the Monte Carlo estimator with its confidence interval of level 0.90. 
     265 
     266 
     267 
     268\subsubsection{Directional Sampling method} 
     269 
     270We evaluate the probability with the Directional Sampling method, whith its default parameters :  
     271\begin{itemize} 
     272  \item 'Slow and Safe' for the root strategy, 
     273  \item 'Random direction' for the sampling strategy 
     274\end{itemize} 
     275 
     276 
     277We evaluate the confidence interval of level $0.95$ and we draw the convergence graph of the Directional Sampling  estimator with its confidence interval of level 0.90. 
     278 
     279 
     280\subsubsection{Latin Hyper Cube Sampling method} 
     281 
     282We evaluate the probability with the Latin Hyper Cube Sampling method with the same parameters as the Monte Carlo method and we draw the convergence graph of the LHS estimator with its confidence interval of level 0.90. 
     283 
     284 
     285 
     286 
     287 
     288\subsubsection{Importance Sampling method} 
     289 
     290 
     291We evaluate the probability with the Importance Sampling method in the standard sapce, with the same parameters as the Monte carlo method. The importance distribution is the normal one, centered on the standard design point and which standard deviation is 4. The importance sampling is performed in the standard sapce.\\ 
     292 
     293We fix the BlockSize is fixed to 1 and the MaximumOuterIteration to $4\, 10^4$.\\ 
     294 
     295We draw the convergence graph of the Importance Sampling  estimator with its confidence interval of level 0.90. 
     296 
     297%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
     298\subsection{The Python script} 
     299 
     300 
     301%\input{scriptExample_beam.py} 
     302 
     303 
     304 
     305\subsection{Output of the Python script} 
     306 
     307%\input{resultatExampleBeam} 
     308 
     309 
     310\subsection{Figures} 
     311 
     312 
     313The probability density function (PDF) of each marginal is given in Figures \ref{pdfE} to \ref{pdfI}. 
     314 
     315 
     316\begin{figure}[Hhbtp] 
     317\begin{minipage}{9.8cm} 
     318    \begin{center} 
     319    \includegraphics[width=7cm]{distributionE_pdf.pdf}  
     320    \caption{Probability density function of the parameter E} 
     321    \label{pdfE} 
     322    \end{center} 
     323\end{minipage} 
     324\hfill 
     325\begin{minipage}{9.8cm} 
     326    \begin{center} 
     327    \includegraphics[width=7cm]{distributionF_pdf.pdf}  
     328    \caption{Probability density function of the parameter F} 
     329    \label{pdfF} 
     330    \end{center} 
     331\end{minipage} 
     332\end{figure} 
     333 
     334 
     335\begin{figure}[Hhbtp] 
     336\begin{minipage}{9.8cm} 
     337    \begin{center} 
     338    \includegraphics[width=7cm]{distributionL_pdf.pdf}  
     339    \caption{PDFof the parameter L} 
     340    \label{pdfL} 
     341    \end{center} 
     342\end{minipage} 
     343\hfill 
     344\begin{minipage}{9.8cm} 
     345    \begin{center} 
     346    \includegraphics[width=7cm]{distributionI_pdf.pdf}  
     347    \caption{PDF of the parameter I} 
     348    \label{pdfI} 
     349    \end{center} 
     350\end{minipage} 
     351\end{figure} 
     352 
     353The probability density function (PDF) and the cumulative density function (CDF) of the deviation fiited with the kernel smoothing metid are drawn in Figures \ref{KernelSmoothing} and  \ref{KernelSmoothing2}. 
     354 
     355 
     356 
     357\begin{figure}[Hhbtp] 
     358\begin{minipage}{9.8cm} 
     359    \begin{center} 
     360    \includegraphics[width=7cm]{smoothedPDF.pdf} 
     361    \caption{PDF of the deviation with the kernel smoothing method.} 
     362    \label{KernelSmoothing} 
     363    \end{center} 
     364\end{minipage} 
     365\hfill 
     366\begin{minipage}{9.8cm} 
     367    \begin{center} 
     368    \includegraphics[width=7cm]{smoothedCDF.pdf} 
     369    \caption{CDF of the deviation with the kernel smoothing method.} 
     370    \label{KernelSmoothing2} 
     371    \end{center} 
     372\end{minipage} 
     373\end{figure} 
     374 
     375 
     376The superposition of the kernel smoothed density function and the normal fitted from the same sample with the maximum likelihood method is drawn in Figure \ref{superp}. 
     377 
     378 
     379\begin{figure}[Hhbtp] 
     380\begin{center} 
     381    \includegraphics[width=9cm]{smoothedPDF_and_GaussianPDF.pdf} 
     382\end{center}  
     383    \caption{Superposition of the kernel smoothed density function and the normal fitted from the same sample.} 
     384    \label{superp} 
     385\end{figure} 
     386 
     387The importance factors from the FORM method are given in Figure \ref{FormIF}. 
     388 
     389\begin{figure}[Hhbtp] 
     390\begin{center} 
     391    \includegraphics[width=9cm]{ImportanceFactorsDrawingFORM.pdf} 
     392\end{center}  
     393    \caption{FORM importance factors of the event : deviation > 30 cm.} 
     394    \label{FormIF} 
     395\end{figure} 
     396 
     397The convergence graphs of the simulation methods are given in Figures \ref{MCConvergence} to \ref{LHSConvergence}. 
     398 
     399 
     400\begin{figure}[Hhbtp] 
     401\begin{minipage}{9.8cm} 
     402    \begin{center} 
     403    \includegraphics[width=7cm]{convergenceGrapheMonteCarlo.pdf} 
     404    \caption{Monte Carlo convergence graph.} 
     405    \label{MCConvergence} 
     406    \end{center} 
     407\end{minipage} 
     408\hfill 
     409\begin{minipage}{9.8cm} 
     410    \begin{center} 
     411    \includegraphics[width=7cm]{convergenceGrapheLHS.pdf} 
     412    \caption{LHS convergence graph.} 
     413    \label{LHSConvergence} 
     414    \end{center} 
     415\end{minipage} 
     416\end{figure} 
     417 
     418 
     419 
     420 
     421\begin{figure}[Hhbtp] 
     422\begin{minipage}{9.8cm} 
     423    \begin{center} 
     424    \includegraphics[width=7cm]{convergenceGrapheDS.pdf} 
     425    \caption{Directional Sampling convergence graph.} 
     426    \label{DSConvergence} 
     427    \end{center} 
     428\end{minipage} 
     429\hfill 
     430\begin{minipage}{9.8cm} 
     431    \begin{center} 
     432    \includegraphics[width=7cm]{convergenceGrapheIS.pdf} 
     433    \caption{LHS convergence graph.} 
     434    \label{LHSConvergence} 
     435    \end{center} 
     436\end{minipage} 
     437\end{figure} 
     438 
     439 
     440 
     441 
     442\subsection{Results comments} 
     443 
     444\subsubsection{Min/Max approach} 
     445 
     446The Min/Max approach enables to evaluate the range of the deviation.\\ 
     447 
     448We note that the use of an experiment plane may be benefical with regard the random sampling technique as we can catch more easily (which means with less evaluations of the limit state function) the extrem values of the output variable of interest :h ere, we have managed to catch both extrem bounds of the deviation with the composite experiment plane, whereas the random sampling technique did not manage to give a good evaluation of them.\\ 
     449 
     450Note that the composite experiment plane has 73 points, where as the random sampling technique has been effected with $10^4$ points. 
     451 
     452 
     453 
     454\subsubsection{Central tendancy approach} 
     455 
     456The Taylor variance decomposition has given a good approximation of  the mean value of the deviation : the value is comparable to the one obtained with the random technique. Furthermore, note that the Taylor variance decomposition required only 1 evaluation of the limit state function, whereas the random sampling technique required $10^4$ evaluations.\\ 
     457 
     458The second order evaluation of the mean by the  Taylor variance decomposition method adds no information, which probably means that around the mean point of the input random vector, the limit state function is well approximated by its tangent plane.\\ 
     459 
     460The importance factors indicate that the mean of the deviation is mostly influenced by the uncertainty of the variable F.\\ 
     461 
     462The kernel smoothing technique enables to have a look on the distribution shape and  another approximation of the mean value of the deviation.\\ 
     463Note that the normal fitting on the sample is not adapted. 
     464 
     465 
     466 
     467\subsubsection{Threshold exceedance approach} 
     468 
     469The whole event probabilities evaluated from the simulation methods are equivalent and confirm the event probability evaluated with FORM.\\ 
     470 
     471Note that the FORM probability required only 176 evaluations of the limit state function whereas the Monte Carlo probability required 17300 evaluations, the Directional Sampling one 17297 evaluations and the LHS one 20300 evaluations.\\ 
     472The Importance Sampling is a simulation method but the importance density has been centered around the design point, where the threshold exceedance is concentrated. That's why the succession of the FORM technique and the Importance sampling one where the importance density is a normal distribution centered around the design point, performed in the standard space, seems to be the better compromise between the limit state evaluation calls number and the probability evaluation precision.\\ 
     473 
     474The simulation methods give a confidence interval, which is not possible with FORM.\\ 
     475 
     476FORM ranks the influence of the input uncertainties on the realisation of the threshold exceedance event : the variable F is largely the more influent. Thus, if the threshold exceedance probability is judged too high, it is recommanded to decrease the variability of the variable F first. 
     477 
     478 
    740479 
    741480\end{document} 

  • branches/dutfoy/devel/doc/src/Makefile.am

    r977 r984  
    2525include $(top_srcdir)/config/common.am 
    2626 
    27 SUBDIRS      =  ArchitectureGuide DocumentationGuide ReferenceGuide UseCasesGuide UserManual WrapperGuide GNU_free_documentation_licence ContributionGuide ExampleGuide #CodingRulesGuide 
    28 DIST_SUBDIRS =  ArchitectureGuide DocumentationGuide ReferenceGuide UseCasesGuide UserManual WrapperGuide GNU_free_documentation_licence ContributionGuide ExampleGuide #CodingRulesGuide 
     27SUBDIRS      =  ArchitectureGuide DocumentationGuide ReferenceGuide UseCasesGuide UserManual ExampleGuide WrapperGuide GNU_free_documentation_licence ContributionGuide ExampleGuide #CodingRulesGuide 
     28DIST_SUBDIRS =  ArchitectureGuide DocumentationGuide ReferenceGuide UseCasesGuide UserManual ExampleGuide WrapperGuide GNU_free_documentation_licence ContributionGuide ExampleGuide #CodingRulesGuide 
    2929 
    3030EXTRA_DIST   = logoOpenTURNS.jpg 

  • branches/dutfoy/devel/doc/src/ReferenceGuide/OpenTURNS_ReferenceGuide.tex

    r906 r984  
    1 %Copyright (c)  2007  EDF-EADS-PHIMECA. 
     1%Copyright (c)  2005  EDF-EADS-PHIMECA. 
    22%  Permission is granted to copy, distribute and/or modify this document 
    33%  under the terms of the GNU Free Documentation License, Version 1.2 

  • branches/dutfoy/devel/doc/src/ReferenceGuide/global_methodology_content.tex

    r906 r984  
    1 %Copyright (c)  2007  EDF-EADS-PHIMECA. 
     1%Copyright (c)  2005  EDF-EADS-PHIMECA. 
    22%  Permission is granted to copy, distribute and/or modify this document 
    33%  under the terms of the GNU Free Documentation License, Version 1.2 

  • branches/dutfoy/devel/doc/src/ReferenceGuide/reference_guide_content.tex

    r906 r984  
    1 %Copyright (c)  2007  EDF-EADS-PHIMECA. 
     1%Copyright (c)  2005  EDF-EADS-PHIMECA. 
    22%  Permission is granted to copy, distribute and/or modify this document 
    33%  under the terms of the GNU Free Documentation License, Version 1.2 

  • branches/dutfoy/devel/doc/src/ReferenceGuide/reference_guide_title.tex

    r906 r984  
    1 %Copyright (c)  2007  EDF-EADS-PHIMECA. 
     1%Copyright (c)  2005  EDF-EADS-PHIMECA. 
    22%  Permission is granted to copy, distribute and/or modify this document 
    33%  under the terms of the GNU Free Documentation License, Version 1.2 

  • branches/dutfoy/devel/doc/src/UseCasesGuide/OpenTURNS_UseCasesGuide.tex

    </
    r982 r984  
    41714171# Give directly to the 'poutreReduced' function a gradient evaluation method  
    41724172# thanks to the finite difference technique 
    4173     # For example, radient technique : non centered finite difference method 
     4173    # For example, gradient technique : non centered finite difference method 
    41744174    myGradient = NonCenteredFiniteDifferenceGradient(NumericalPoint(2, 1.0e-7), poutreReduced.getEvaluationImplementation()) 
    41754175    print "myGradient = ", myGradient 
    …… 
    59375937# Draw the convergence graph and the confidence intervalle of level alpha