Le nucléaire au thorium

Présent dans presque tous les débats depuis la catastrophe de Fukoshima la production d’électricité via l’énergie nucléaire est souvent critiquée, décriée.

Souvent on pense qu’il faut absolument sortir de cette source d’énergie ? cause de son danger et des déchets qu’elle laisse derrière elle. Pourtant il est souvent on oublie de préciser quelque chose : notre source d’énergie nucléaire est l’uranium 235 et 238.

La réaction se passe ainsi :

message picture

Parmi les déchets on trouve donc de l’Uranium 235 (non consumé ou produit de la réaction) et du Plutonium. C’est ce dernier qui pose problème : il est très radioactif et très long ? se désintégrer.

La France a choisi de donner sa chance au Plutonium 239 via la création de MOX, la Chine, elle a décidé, en 2010, d’expérimenter une autre alternative : le thorium.

Une différence fondamentale : matériaux fissiles, matériaux fertiles

Il y a plus d’un siècle désormais deux scientifiques, Pierre et Marie Curie mettaient en avant la radioactivité du Thorium, découvert ? la fin du XIXème siècle. La radioactivité c’est la capacité ? perdre de l’énergie (rayonnement alpha, beta + ou-, ou gamma) pour créer un nouveau noyau plus stable (qui rayonnera moins). C’est différent de la possibilité de fissionner un noyau comme c’est le cas pour l’Uranium 235 ou 238.

Le thorium ne fait pas partie des matériaux fissiles, il serait très difficile de le fracturer en le bombardant de neutron. Cependant, ce dernier, une fois qu’il a capté un neutron se met ? être fortement radioactif. Et le résultat de cette radioactivité sera de l’Uranium 233, qui lui, est fissile.

Cette capacité ? donner naissance ? un noyau fissile fait que le Thorium est appelé fertile.

Cela a une conséquence importante : il faut amorcer la réaction. C’est ? dire qu’il faut quand même mélanger le Thorium ? de l’Uranium (souvent 235) pour que la réaction fonctionne.

Mais la grande force (ou la grande faiblesse selon qu’on soit pour ou contre la bombe atomique…) c’est que cette réaction ne produira que très peu de Plutonium (uniquement les résidus de l’amorçage).

Une autre conséquence non négligeable qui a largement ralenti le développement des réacteurs ? Thorium c’est que celui-ci devient très fortement radioactif au cours de la réaction et que des très puissants rayons gamma sont relâchés. Cependant qui dit amélioration des matériaux et de la robotique dit possibilité d’envisager la construction des réacteurs ? Thorium.

Un fonctionnement à part

Une grande force du Thorium est qu’il permet très facilement d’être exploité ? l’état liquide plutôt que solide à l’intérieur de réacteurs portant l’acronyme LFTR.

Les premiers prototypes de ce type de réacteurs date des années 40. Ce qui explique leur abandon : la filière du thorium n’était pas créé mais en plus le thorium ne créait pas de Plutonium dont on avait besoin pour les bombes atomiques de l’époque.

Depuis le forum Génération IV de nouveaux prototype comme SuperPhoenix ou le Rubbiatron

Dans tous les cas on remarque que le danger, jusque l? inhérent au nucléaire, d’emballement de la réaction peut être supprimé. En effet ces réacteurs peuvent fonctionner de manière viable en régime dit “sous-critique” durant lesquels la réaction peut s’arrêter toute seule si on la prive de combustible ou de neutrons.

Le traitement des déchets

Bien que les déchets soient moins radioactifs et pour moins longtemps, ils existent et leur demie-vie reste très élevée (un millénaire), pour autant différents projets ont été mis au point, notamment les ADS : Systèmes pilotés par accélérateurs qui permettent la transmutation des déchets vers d’autres qui se dégradent plus rapidement. Ces projets semblent prometteurs :

Les études de faisabilité des ADS sont maintenant bien avancées. Des travaux ont été effectués au plan national, au CEA et en collaboration CEA-CNRS ; au plan européen, sous l?égide du « Technical Working Group » (TWG) et dans le cadre de projets européens du 5e et, maintenant, du 6e PCRD. Des industriels ont pris une part importante ? ces travaux. En collaboration CEA-CNRS, des expériences ? puissance zéro ont été effectuées ? Cadarache sur la maquette critique « Masurca » (CEA-Cadarache) et un injecteur de protons de haute intensité est en construction au CEA Saclay.

Chiffres en vrac

  • 200 fois plus de Thorium que d’Uranium dans la nature, on trouve de très bons gisements partout dans le monde, notamment, pour nous, en Bretagne
  • 3,5 millions de fois la capacité du charbon
  • 14.5 milliards d’année : c’est la demie vie du Thorium 232, plus importante que l’âge de la terre
  • 10 000$ : c’est le coût annuel estimé d’un réacteur de type LFTR d’une puissance de 1GW, soit 40 fois moins qu’un réacteur ? Uranium 235/238.
  • 3000m² : la taille estimée pour une centrale de type LFTR soit 100 fois moins qu’une centrale ? l’Uranium 235/238

Les canvas HTML5 : chapitre 2 les calques

Ainsi continue la suite d’articles que j’avais commencée a propos des canvas html5 il y a deux semaines.

Je suis très heureux de constater que cet article est déjà bien référencé dans Google. Cela ne fait que renforcer ma motivation.

Ainsi, ce second chapitre portera sur la possibilité de créer des calques avec des canvas.

Le concept de calque :

Le concept des calques est très utilisé dans les logiciels de traitement d’image complexes style photoshop ou gimp.

Il s’agit de séparer votre images en plusieurs sous-images que vous superposerez ensuite selon un mode que vous choisirez, par exemple via un xor…

Les canvas permettent d’émuler ce genre de comportement assez intuitivement.

En effet , en créant plusieurs calques avec un fond transparent, puis en les superposant via CSS, on a autant de calques que de canvas.

Ce sera par la suite grâce ? la propriété z-index que vous pourrez switcher entre deux calques.

Pour gérer l’opacité il faudra utiliser le système rgba qui vous permet de renseigner une couleur sur 32bits avec un canal alpha.

Par exemple pour créer une ligne estompée de moitié et qui permet de voir au travers une partie du fond, vous aurez ce code :
[cc lang=”javascrip”]
context.strokeStyle=’rgba(255,0,0,0.5)’;
context.moveTo(0,0);
context.lineTo(100,100);[/cc]
En parlant de l’opacité un problème auquel j’ai dû faire face est qu’habituellement, je stocke mes couleurs sous forme d’entier, puis avec un jeu de masque/décalage de bit je pouvais obtenir les composantes rouge vertes et bleues facilement.

Le problème ici, c’est que le canal alpha est représenté par un flottant, pas un entier de 0 à 255.

En fait, il suffit alors de stocker la couleur sur un entier 32 bits, de récupérer la composante de poids faible et de la diviser par 255.
[cc lang=”javascript”]/**
*convertit un entier en couleur rgba
*@param integer l’entier à convertir
*@return la couleur rgba désirée
*/
var getRGBAColorFromInteger = function(integer){
return ‘rgba(‘+(integer>>24) +’,’+((integer>>16) & 255) +’,’+((integer >> 8) & 255) +’,’+((integer & 255)/255)+’)’;

}[/cc]

Obtenir les dessins faits sur un calque :

Une fois que vous avez travaillé sur votre calque, il peut être intéressant de connaître tous les pixels qui y ont été dessinés, notamment pour coder une fusion spéciale ou tout simplement pour déplacer le calque par exemple.

Pour faire cela, il vous faudra utiliser la fonction getImageData qui vous retourne un objet/structure composé de :

  1. un champ length = 4*nombre de pixel
  2. un champ data = un tableau où sont rangés vos pixel. Un pixel équivaut ? quatre cases dans ce tableau ([4n]=>Rouge, [4n+1]=>Vert, [4n+2]=>Bleu, [4n+3]=>alpha)

La fonction getImageData vous demande quatre arguments :

  1. x = L’abscisse ? partir de laquelle on commence
  2. y = L’ordonnée ? partir de laquelle on commence
  3. width = La largeur du rectangle qu’on désire sélectionner. Cette largeur peut être positive ou négative selon qu’on veuille aller ? droite ou ? gauche.
  4. height = La hauteur du rectangle qu’on désire sélectionner. Cette hauteur peut être positive ou négative selon qu’on veuille aller en haut ou en bas

Notons que si vous sélectionnez un pixel en dehors du canvas, il sera mis en tant que noir transparent dans le imageData (rgba(0,0,0,0)) cela est très courant avec les canvas. Par exemple la méthode fillRect() remplit le canvas de pixels noirs transparents.

Cela peut être gênant puisque le noir transparent se confond avec le background sur lequel est posé le canvas. Ainsi, si vous ne prenez pas peine d’initialiser correctement votre canvas, il se peut que vous ayez des comportement inattendus, par exemple pour des algorithmes de remplissage.

Mettre des pixels dans un canvas :

Cette fois ci il suffira d’utiliser la fonction putImageData. Les paramètres de cette dernière sont ;

  1. imageData = l’objet ImageData ? copier
  2. x = L’abscisse ? partir de laquelle on commence
  3. y = L’ordonnée ? partir de laquelle on commence
  4. width = La largeur du rectangle qu’on désire copier. Cette largeur peut être positive ou négative selon qu’on veuille aller ? droite ou ? gauche.
  5. height = La hauteur du rectangle qu’on désire copier. Cette hauteur peut être positive ou négative selon qu’on veuille aller en haut ou en bas

Cette méthode est apparemment très optimisée pour remplir des canvas, d’après le MDN.

Les canvas HTML5 : chapitre 1 les courbes de bézier

Depuis quelques temps déjà , html5, bien que non finalise, nous propose des fonctionnalités avancées dans l’interaction avec les utilisateurs. Une des premières ameliorations implémentée fut le canvas et son AP.
Etant actuellement plonge dans un projet qui se base presqu’uniquement sur un canvas pour interagir avec l’utilisateur, je vais écrire une série d’articles sur certaines fonctionnalités avancées de cet élément.Bézier dans le cadre d’un logiciel de dessin. Je choisis cet exmple parce qu’il est proche de ce que je fais dans mon projet, mais aussi parce qu’il utilise toutes les notions importantes que je désire exposer dans mon article.
Prerequis : dessiner sur un canvas
Dessiner sur un canvas ce n’est pas manipuler l’objet de l’arbre DOM en lui même mais un objet de type CanvasRenderingContext2d. Il existe un équivalent 3d mais il n’est soit que partiellement implémenté soit peu performant. Seul chrome 17 intégrant une implementation stable de la version 3d.
Vous pourrez bien sur ajouter vos propres fonctions a cet objet grâce au prototype.

Une courbe de bezier qu’est-ce que c’est?
Entrons dans le vif du sujet en donnant une définition concise des courbes de bezier.
Ce sont des courbes du plan qui sont parametrees par un polynôme. De manière plus graphique vous avez une courbe se rendant d’un point a un autre qui est guidée au départ et a l’arrivée par ce qu’on appelle des points de contrôle. La courbe part du point source, se dirige vers le premier point de controle, puis le second avant d’atteindre le point d’arrivée.
Avec les canvas, il n’existe que deux types de courbes de bezier. Le premier type est appelé quadrique et dans les faits c’est a peu de choses près une courbe de bezier dont les points de contrôle sont au même endroit.
Le dessin, d’une courbe ressemblera donc a:
[code=javascript]
var canvas = document.getElementById(‘id_canvas’);
canvas.height=400;
canvas.width=400;
var context =canvas.getContext(“2d”);
context.beginPath();//on débute un chemin, nécessaire pour que nos courbes soient tracées.
context.moveTo(0,0);//on se met au point de depart
context.bezierCurveTo(50,50,100,0,400,400);//on fait une courbe jusqu’au point en bas a gauche avec pour point de contrôle (50,50) et (100,0)
context.stroke();//et on trace
[/code]

La notion de chemin

Comme je vous l’ai ecrit juste au dessus nous avons besoin de la fonction beginPath() pour que plus tard on puisse tracer nos courbes. Cette notion est très importe car elle permet de manipuler plus facilement les formes tracées ou non…
Un chemin c’est un ensemble de point parcouru par nos fonctions de mouvement. Si un chemin revient a son point de départ, on dit qu’il est ferme et on peut alors le remplir avec fill(). L’avantage majeur du chemin, c’est que tant qu’on ne le lui demande pas, il ne se trace pas. Cela permet par exemple de vérifier qu’un point se trouve sur une courbe quelconque (imaginons, la courbe representative d’une fonction.).Cette vérification donnera lieu a de plus amples détails par la suite dans cet article. Mais nous pouvons déjà noter que la fonction isPointInPath existe qui permet de faire cela.
En ayant compris la notion de chemin, on voit néanmoins une limite de isPointInPath : elle ne prend pas en compte l’épaisseur des lignes, donc elle n’est pas utilisable telle quel dans le cadre de détection d’interaction avec l’utilisateur.

Modifier une courbe de bezier

Comme nous l’avons vu, une courbe de bezier est définie en javascript par quatre points. Faire bouger ces quatre points est donc la clef pour modifier une courbe de bezier.
Pour le bien de l’expérience, nous allons ajouter un modèle a notre application afin de retenir ces quatre points.
[code=javascript]
var BezierCurve=function(source,dest,c1,c2,width){
this.source=source;
this.dest=dest;
this.c1=c1;
this.c2=c2;
this.width=width;
/**
* dessine la courbe dans le contexte donne
*@param context l’objet CanvasRenderingContext2d dans lequel on veut dessiner.
*/
this.draw = function(context){
context.beginPath();
context.moveTo(this.source.x,this.source.y);
context.bezierCurveTo(this.c1.x,this.c1.y,this.c2.x,this.c2.y,this.dest.x,this.dest.y);
var old = context.lineWidth;//on sauvegarde les anciens parametres
context.lineWidth=this.width;
context.stroke();
};
}
[/code]
Ensuite il nous faudra détecter une selection de la courbe avec la souris. Pour cela il existe trois méthodes :
-utiliser la courbe réelle et la fonction isPointInPath, avec pour problème que l’épaisseur n’est pas prise en compte. Il faudra alors recourir a une astuce, a savoir un chemin qui sera aussi épais que la courbe dessinée. En fait on dessine autant de de translate de la courbe qu’il n’y a d’épaisseur.
-évaluer la fonction en un certain nombres de points puis vérifier que la distance entre ces points et l’endroit ou l’on a cliqué. Le problème principal ici c’est qu’il faut beaucoup de points d’évaluations pour avoir quelque chose de fiable. Il faut en plus ajouter que comme ces courbes ne sont pas linéaires il y a fort a parier que vos points ne seront pas équitablement répartis sur la courbe et que les endroits avec une pente douce seront mieux évalués que les autres. D’après mes tests il faudra au minimum 100 points pour décrire fiablement toute courbe sur un ça vas 300×300. 10000 donne un résultat proche de la courbe réel et 1000 semble un bon compromis.
-approximer la courbe par ses tangentes à la manière d’Euler. L’avantage c’est qu’on connaît une formule relativement simple pour calculer la distance d’un point a une droite dans un repère orthonormé.[img]http://upload.wikimedia.org/wikipedia/fr/math/f/8/0/f80e0b45d63614900e045883a662413b.png[/img]
Il faudra néanmoins faire attention, nous regardons la distance à un segment dans notre cas, c’est-à-dire que si nous ne sommes pas dans le rectangle de diagonale descendante formée par notre segment, il ne sert a rien d’évaluer la distance, sans compter que ça serait même un bug. Le minimum syndical sera ici 10 évaluations sur un canvas 300×300, 50 donnant un superbe résultat et 20 étant un bon compromis.
en noir la courbe modèle, en rouge les évaluation avec des points, en bleu l’approximation linéaire.
[img]/blog/web/download/img_bezier.png[/img]

Si je vous présente les trois méthodes c’est tout simplement parce qu’elles peuvent être utiles dans différents cas d’utilisation. Néanmoins dans le cas de la détection de click sur des courbes de bezier quelconque’ il semblerait que la plus efficace, de loin, soit la dernière, vient ensuite isPointInPath et enfin l’évaluation d’un certain nombre de points. Pour plus de précision, suivez [url=ce lien]http://jsperf.com/isovercurve[/url] qui détaille des tests fais sur pas mal de navigateurs (même ma tablette archos y est passée!).

Avant de passer au dernier point de cet article, j’aimerai citer une propriété des courbes de bezier qui vous permettra d’améliorer grandement les performances de votre application. Pour qu’un point soit sur la courbe alors il est nécessaire qu’il soit a l’intérieur de la boite délimitée par les coordonnées des quatre points. Si ça n’est pas le cas, les evaluations coûteuses que je vous ai présentées sont inutiles!

Faire des courbes plus complexes

Les courbes de bezier peuvent être, dans un cas plus général une courbe de bezier peut se courber un nombre plus important que les courbes cubiques. En fait le nombre de courbures maximum est égal au nombre de points de contrôle.
Comme les canvas n’ont pas la possibilité de faire de telles courbes nativement, il faut tricher. En fait il suffit de mettre bout à bout plusieurs courbes cubiques. C’est ce que font les logiciels de dessins habituels.

Conclusion

Cet article touche à sa fin. Nous avons vu combien le potentiel des courbes de bezier était important et aussi comment interagir avec ces courbes. Cela dit on peut remarquer qu’il y a un gros travail à faire pour étendre l'[acr=Application Programming Interface]API[/acr]. C’est pourquoi je vous offre quelques [url=fonctions utilitaires]/blog/web/download/overloading_canvas.js[/url] à ajouter au prototype du CanvasRenderingContext2d.

De retour

Suite au changement de version de mon hébergeur, mon blog a disparu et je n’ai même pas eu le temps de récupérer l’ancienne bdd donc presque tous les articles auront disparu. Néanmoins je prépare mon retour en force!
Pour ceux qui me suivront je vous souhaite donc la bienvenu sur la nouvelle version de mon blog.