IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage C++ Discussion :

Algorithme cfg électronique


Sujet :

Langage C++

  1. #1
    Nouveau Candidat au Club
    Homme Profil pro
    Ingénieur-chercheur
    Inscrit en
    Septembre 2015
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur-chercheur

    Informations forums :
    Inscription : Septembre 2015
    Messages : 3
    Points : 1
    Points
    1
    Par défaut 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 ?

  2. #2
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 113
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 113
    Points : 32 958
    Points
    32 958
    Billets dans le blog
    4
    Par défaut
    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 ?
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  3. #3
    Nouveau Candidat au Club
    Homme Profil pro
    Ingénieur-chercheur
    Inscrit en
    Septembre 2015
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur-chercheur

    Informations forums :
    Inscription : Septembre 2015
    Messages : 3
    Points : 1
    Points
    1
    Par défaut
    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.

  4. #4
    Expert confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2012
    Messages
    1 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2012
    Messages : 1 711
    Points : 4 442
    Points
    4 442
    Par défaut
    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.

  5. #5
    Expert éminent sénior
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 612
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 612
    Points : 30 611
    Points
    30 611
    Par défaut
    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

    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 (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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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"
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  6. #6
    Membre confirmé
    Avatar de Captain'Flam
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2011
    Messages
    273
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Février 2011
    Messages : 273
    Points : 455
    Points
    455
    Billets dans le blog
    1
    Par défaut
    Pour le plaisir de l'algorithmique, voici une petite version (qui pourrait aussi bien être en C) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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é.
    Captain'Flam
    anciennement Sopsag, aka Hadrien
    Win seven x64 & Win 10 / Visual 2017 / Python 2.7 / Eclipse

  7. #7
    Nouveau Candidat au Club
    Homme Profil pro
    Ingénieur-chercheur
    Inscrit en
    Septembre 2015
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur-chercheur

    Informations forums :
    Inscription : Septembre 2015
    Messages : 3
    Points : 1
    Points
    1
    Par défaut
    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 ?

  8. #8
    Membre confirmé
    Avatar de Captain'Flam
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2011
    Messages
    273
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Février 2011
    Messages : 273
    Points : 455
    Points
    455
    Billets dans le blog
    1
    Par défaut
    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...
    Captain'Flam
    anciennement Sopsag, aka Hadrien
    Win seven x64 & Win 10 / Visual 2017 / Python 2.7 / Eclipse

Discussions similaires

  1. Algorithme de randomisation ... ( Hasard ...? )
    Par Anonymous dans le forum Assembleur
    Réponses: 8
    Dernier message: 06/09/2002, 15h25
  2. recherches des cours ou des explications sur les algorithmes
    Par Marcus2211 dans le forum Algorithmes et structures de données
    Réponses: 6
    Dernier message: 19/05/2002, 23h18
  3. Recherche de documentation complète en algorithmes
    Par Anonymous dans le forum Algorithmes et structures de données
    Réponses: 1
    Dernier message: 29/03/2002, 13h09
  4. Algorithme génétique
    Par Stephane.P_(dis Postef) dans le forum Algorithmes et structures de données
    Réponses: 2
    Dernier message: 15/03/2002, 18h14

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo