Algorithme cfg électronique

Ami du triturage de cerveau bonjour !

Pour mon travail je suis entrain de plancher sur l'élaboration d'un algorithme permettant de générer toutes les configurations électroniques possédant n électrons. Je m'explique :

Supposons que j'ai 3 électrons. Ces électrons je peux les répartir par exemple sur 4 orbitales. Chaque orbitale peut en contenir un certain nombre (grâce à la dégénérescence). Par exemple :

Dégé : 2 2 2 4
orb : 1s1/2 2s1/2 2p1/2 2p3/2
conf : 2 1 0 0 <=== configuration fondamentale
conf : 2 0 1 0
conf : 2 0 0 1 <== OK
conf : 1 2 0 0
conf : 1 1 1 0
conf : 1 1 0 1
....

Je suis à la recherche d'astuce en C++ permettant de résoudre ce problème. Actuellement, la génération de la configuration fondamentale est réalisée + le déplacement du premier électron (jusqu'à OK). Le problème est que pour la suite j'arrive pas à trouver une logique afin de généraliser le code à n électron et k orbitale.

Auriez-vous des idées ?

Alors moi j'ai rien compris à cette histoire de dégénérescence etc, mais t'as pas juste besoin de 4 boucles imbriquées ?

Pour 4 orbitales, 4 boucles imbriquées suffisent. Mais il faut que le code soit généralisable à plus d'orbitales. La dégénérescence c'est juste le nombre d'électrons maximum que tu peux mettre dans une orbitale.

Pareil, pas compris grand chose.
De mémoire un atome peut avoir 8 ou 9 orbitales et 150+ électrons, ça commence à faire un paquet de possibilités et il faudra peut être (surement même) trouver mieux qu'un algo naïf par brute force.

Je pense qu'une approche récursive peut faire l'affaire : tu pars d'une configuration, tu génères toutes les possibilités à partir de cette conf, et tu rappelles la fonction pour toutes ces confs.

Salut,

Si j'ai bien tout compris (mais cela reste encore à prouver), ton problème vient essentiellement du fait qu'il te faut un nombre de boucle égal au nombre d'orbitales possibles :question:

Si tel est le cas, je crains que tu n'ai pas d'autre choix que de te tourner vers une logique récursive : le résultat pour N orbitales étant égal au résultat que tu aurais obtenu pour N-1 orbitale +"un petit quelque chose" (à définir par toi même).

Dans cette perspective, tu dois veiller à définir ce que l'on appelle le "cas de base". Ici, cela reviendrait à te poser la question de savoir : que se passe-t-il avec une seule orbitale :question: (la réponse étant sans doute : aucune dégénérescence possible ;) ) et le code qui pourra te sortir d'affaire devrait ressembler à quelque chose comme

Code:

---

1 2 3 4 5 6 7 8 9

type calculDegenre(size_t orbitales, /* autres paramètres nécessaires */){ if(orbitales == 1){ /* pas de dégénérescence possible, on renvoie la valeur "actuelle" */ return /* l'un des paramètres sans rien y changer */ } auto temp = calculDegenre(orbitales-, /* autres arguments */); // récupérer le résultat avec N-1 orbitales /* autres manipulations à faire */ return /* résultat final */ }

---

Le tout étant de savoir par quoi il faudra remplacer les "autres paramètres nécessaires", les "autres manipulations à faire" et le "résultat final" ;)

Pour le plaisir de l'algorithmique, voici une petite version (qui pourrait aussi bien être en C) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

#include <iostream> using namespace std ;   void next_config ( const int * maxo , int * o , int size , int first , int nb ) { if (first < size) for ( int n = min( maxo[first],nb ) ; n >= 0 ; n-- ) { o[first] = n ; next_config( maxo,o,size,first+1,nb-n ) ; } else if (nb == 0) { for ( int i = 0 ; i < size ; i++ ) cout << o[i] << ' ' ; cout << endl ; } }   int main () { int iorb [] = { 2,2,2,4 } ; int norb [] = { 0,0,0,0 } ; next_config( iorb,norb,4,0,3 ) ; }

---

ce qui affiche

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

2 1 0 0 2 0 1 0 2 0 0 1 1 2 0 0 1 1 1 0 1 1 0 1 1 0 2 0 1 0 1 1 1 0 0 2 0 2 1 0 0 2 0 1 0 1 2 0 0 1 1 1 0 1 0 2 0 0 2 1 0 0 1 2 0 0 0 3

---

Si j'ai bien compris... (mes cours d'atomistique sont un peu loin)
L'idéal serait de pouvoir énumérer les configurations, mais c'est un peu plus compliqué.

Bonjour à tous,

désolé de la réponse tardive mais j'étais en déplacement. C'est une chouette version que tu nous proposes captain flam. En tout cas tu as bien compris même si t'es cours d'atomistique sont un peu loin ! Qu'est ce que tu entends par les énumérer ? Les compter ?

Par "énumérer", j'entends "itérer".
Une classe itérateur de configurations, avec une méthode init et une méthode next, ou au sens stl du terme, une méthode begin, une méthode end et un opérateur ++.
Ça permet d'éviter que le traitement de la configuration en cours soit dans une callback, ou pire, à l’intérieur de la fonction next_config.
Autant, en python, c'est enfantin avec l'instruction yield, autant en C/C++, on est obligé d'abandonner l'approche récursive et gérer soi-même une pile.
Mais c'est un exercice amusant...