x_all

L'énoncé du problème?En ce qui concerne l’environnement de test je ne vois pas comment être plus clair, en ce qui concerne le programme qui calcule le réseau de ventil, j'ai envie de dire pour résoudre le problème de (explore on s'en fout.les donnée d'entrée c'est une liste de liste, qui est directement au début du code il faut la parcourir suivant les règles de l'algorithme pour sortir, il faut avoir traité toutes les branches en renseignant la valeur de Qa dans le dernier bloc à la racine de l'arbre. Au bout du compte, comme je disais précédemment, je vais externaliser le test et je devrai m'en sortir. Mais bon, un 3D compliqué à rendre pour ce soir....

j'aurai dit pareil... quand j'ai peur je change le nom des variables i devient in ou inc, lstartampion ls2tartampion ect...

illumination nocturne...Si je veux plus être emmerdé par le fait que l’éditeur ne veux pas faire de pas à pas dans la boucle récursive, comme j'ai fait (traitebranche qui met à jour les blocs, il faut que je fasse (testebranche qui renvoie T ou nil dans mon test d'éligibilité au traitement. En faisant ça j'ai une chance de m'en sortir... mais pas le temps aujourd’hui...en plus dans l'idée de modularité ça perpétrai de changer le test si je veux traiter un cas différent... mes excuses pour cette répétition de post, mais les sujets sont différents.

j'ai eu un doute sur la fin de (explore ou j'ai voulu me la jouer pour faire le (setq (cdr dans le test. et puis d'avoir posé l'algo ça m'a monté quelques lacunes je pose donc une v2 mais ça tourne toujours pas. ;; Tex v2, à pour test avec http://joch04.free.fr/images/vrac/debit-ventil3.dwg (defun c:tex (/ ent i in j n lay der sspoly poly lsvtx vtx pt ssblocs lsbloc bloc nombloc hbloc lsbrrecur lsbranche branche tcourant ta QA qc v doc ) (vl-load-com) (setq doc (vla-get-activedocument (vlax-get-acad-object)) ) ;_ Fin de setq (setq lsbrrecur '((("Debit" (0.0 0.0) "3804") ("jonction" (1.0 0.0) "2514") ("Debit" (2.0 0.0) "3811") ("jonction" (3.0 0.0) "2522") ("jonction" (6.0 0.0) "253E") ("jonction" (10.0 0.0) "254C") ) (("Debit" (0.5 1.0) "2B6D") ("Debit" (1.0 1.0) "2B61") ("jonction" (1.0 0.0) "2514") ) (("Debit" (3.0 4.0) "2B55") ("Debit" (3.0 2.0) "2B49") ("jonction" (3.0 0.0) "2522") ) (("Debit" (5.0 2.0) "2B31") ("jonction" (6.0 2.0) "255A") ) (("Debit" (6.0 5.0) "2B3D") ("jonction" (6.0 4.0) "34DA") ("jonction" (6.0 0.0) "253E") ) (("Debit" (8.34004 4.0) "34FE") ("jonction" (6.0 4.0) "34DA") ) ) ) ;_ Fin de setq (explore lsbrrecur) ;; ;; Explore ;; (defun explore (lsbrrecur / brl bloc nombloc nok in) (setq brl (car lsbrrecur) in 0 bloc nil nok 0 ) ;_ Fin de setq ;;boucle pour test si un bloc "jonction" (sauf le dernier) de la branche à Qa =0 (while (< in (length brl)) (setq bloc (nth in brl) hbloc (caddr bloc) nombloc (car bloc) ) ;_ Fin de setq (setq Qa (read (Vb-Val-att (handent hbloc) "Qa" ) ;_ Fin de Vb-Val-att ) ;_ Fin de read ) ;_ Fin de setq ;_ Fin de setq ;; test du Qa d'un bloc qui n'est pas le dernier si oui Nok = 1 (if (and (= 0 Qa) (/= (+ 1 in) (length lsbloc) (= "jonction" nombloc)) ) (setq nok 1) ) ;_ Fin de if (setq in (+ 1)) ) ;_ Fin de while ;; Si nok modifié a 1, on ne peut pas calculer la branche ;; on met donc ce bloc à la fin de celle ci et on rappelle explore ;; avec cette nouvelle liste en espérant que le 1er élément soit traitable (if (= nok 1) (progn (setq lsbrrecur (append (cdr lsbrrecur) (list (car lsbrrecur)) ) ;_ Fin de append ) ;_ Fin de setq ;; permutation à (gile) le 1er devient le dernier (explore lsbrrecur) ) ;_ Fin de progn ;;fp ) ;_ Fin de if ;;fi ;; ;; Si Nok = 0 la branche est traitable ;; on traite, suprime cette branche de la collection et relance sur la nouvelle liste (TraiteBranche brl) (if (/= nil (cdr lsbrrecur)) (prog (setq lsbrrecur (cdr lsbrrecur)) (print "ggrrrrr") (explore lsbrrecur) ) ) ;_ Fin de if ;;;;;;; par ici la sortie !!!! ) ;_ Fin de defun ;;;fd explore ;;;fd explore ;;;fd explore (print "sortie normale de Tex") ;;; Fin de l'undo (vla-endundomark doc) (princ) ) ;_ Fin de defun ;;fin Vsom ;; ;; Traiement d'une branche et maj Qa ;; (defun TraiteBranche (branche / i u bloc hbloc tcourant ta) (setq i 0 bloc nil ) ;_ Fin de setq (while (< i (length branche)) (setq bloc (nth branche i) hbloc (caddr bloc) ) ;_ Fin de setq (Vb-Mod-att (handent hbloc) "Qa" (rtos 100)) (setq i (+ 1 i)) ) ;_ Fin de while ;;;fw ) ;fd ;; Vb-Val-att fonction Vlisp pour lire la valeur d'un attribut (defun Vb-Val-att (ent nomatt / att val) ; ent correspond au handel du bloc (codedxf 5) à utiliser comme ça (setq toto (read (Vb-Val-att (handent handle) "REF"))) (foreach att (vlax-invoke (vlax-ename->vla-object ent) 'getattributes ) ;_ Fin de vlax-invoke (and (eq (vla-get-tagstring att) nomatt) ;comme ils disent les fou du code "tournure élégante !" (setq val (vla-get-textstring att)) ; le ET est équivalent à un si dans ce cas là ) ;car on afffecte Val que si att= nom-att bravo Patrick_35 ) ;_ Fin de foreach val ;; retour de fonction ) ;_ Fin de defun ;; fin Vb-Val-att ;; Vb-Mod-att fonction Vlisp pour modifier la valeur d'un attribut ;; à utiliser comme ça (Vb-Mod-att (handent handle) "NIV" new-val) ;; new-val est une string (defun Vb-Mod-att (ent nom-att nval / att inc vblst-att) (setq inc 0 vblst-att (vlax-invoke (vlax-ename->vla-object ent) 'getattributes ) ;_ Fin de vlax-invoke ) ;_ Fin de setq (while (< inc (length vblst-att)) (if (eq (vla-get-tagstring (nth inc vblst-att)) nom-att ) ;_ Fin de eq (vla-put-textstring (nth inc vblst-att) nval) ) ;_ Fin de if (setq inc (+ 1 inc)) ) ;_ Fin de while ) ; ; fin Vb-Mod-att mais ça marche pas mieux. et ça boucle plus ça plante...

l'algorithme, c'est celui la: Partir d’une copie de la liste des branches Tester la 1ere Si un seul des Qa des blocs "jonction" de la branche (sauf le dernier) =0 je passe le 1er éléments à la fin et je lance (explore sur cette nouvelle liste de branche. Si tous les Qa sauf le dernier /=0 on lance (traitement branche qui rempli le Qa du bloc extrémité à 1 si on en est pas à la dernière branche Je supprime la branche de la liste de branche (cdr Et je relance (explore sur cette liste de branche tronquée je pense pas que le problème soit là. l'environnement de test, c'est le doublet Tex.lisp posté ici http://cadxp.com/top...post__p__266116 avec le dessin à charger là. http://joch04.free.f...bit-ventil3.dwg si je mélange de l'itératif et du récursif, c'est que le récursif sort les branche traitées de la liste de branches et l’itératif c'est pour parcourir la branche car on doit tester tous les nœuds pour la valider ''''''''''. l’indentation pourrie, je bosse au taff et à la maison, l’indentation auto me joue des tours. pourtant j'y met toujours un coup d’équerre avant de poster. les fonctions d'ordre supérieur (apply, mapcar, vl-remove-if, etc.).... comment dire... j'en ai une vague notion, je vais potasser.... mais ça fait refaire un algorithme...

Re bonsoir, merci de consacrer du temps pour nous. Je croyais avoir été simple et concis.. peut être un peut trop simple pour être compréhensible. L’histoire est un peu longue je vais essayer d’être plus clair. Je cherche à calculer un réseau de ventilation. Sur une arborescence de polylignes il y a des blocs (dynamiques) avec des attributs. Le but premier est de ramener la somme des débits à la source en calculant à l’avancement le débit des bouches dans la canalisation pour en déduire les diamètres mini en fonction de la vitesse. Dans un autre post : http://cadxp.com/top...052#entry266052 j’ai résolu le problème d’une branche et définit une règle pour déterminer si une branche est calculable (car toutes les sous-branches sont déjà calculées). La règle pour la construction de cet arbre, c’est que le point 1 de la polyligne est le plus éloigné de la source, 2 types de bloc sont possible sur les vertex soit une Bouche soit un Tè. Chaque branche se termine par un Té. Le bloc T s’il n’est pas le dernier cumule de Q courant de la branche et un Q auxiliaire de la branche fille. Si le T est sur une extrémité, le champ à remplir est le Qa . La condition pour que la branche parent soit calculable c'est que tous les bloc T intermédiaire aient une valeur de Qa non nulle. Cette partie du code reste à peaufiner et mériterai peut être un long débat, mais bon on va dire que ça marche pour partir directement de la liste de branches moulinée en amont a partir du dessin chargeable ici (et nécessaire pour faire des tests) http://joch04.free.f...bit-ventil3.dwg Dans le présent post,je posais une question sur la sortie d’une fonction récursive indispensable au parcours de mon arbre. Dans le code que j’ai posté ici, j’ai éludé la partie ou je mouline mon arbre pour en sortir les listes ordonnées de chaque branche pour faire un setq Listedesbranches. J'ai limité la partie (traitement à sa plus simple expression je met tous les attributs Qa de la branche à 1 Donc l’algorithme que je cherche à faire pour la fonction (explore c’est : Partir d’une copie de la liste des branches Tester la 1ere Si Qa/=0 je passe le 1er éléments à la fin et je lance (explore sur cette nouvelle liste de branche. Si Qa=0 je calcule la branche (et rempli Qa à 1 avec (traitement branche Je supprime la branche de la liste de branche (cdr Et je relance (explore sur cette liste de branche tronquée Les symptômes dans le code que j’ai posté ? ça boucle et je suis obligé de passer par le menu débogage pour arrêter l’interprétation. Le soucis, c’est que je programme 1 ou 2 fois par an et que je suis donc plutôt nul. D’où le formatage peu orthodoxe même si je t’assure j’essaye de faire de mon mieux. J'ai peur de me prendre les pieds dans les portées de variable ou d'avoir oublier un truc énorme qui m'aurai péter à la gueule en mode pas à pas (j'en fait des grosses parfois) Je passe mon temps à interpréter ligne par ligne pour corriger mes bugs. Quand j’ai écrit (explore, je n’ai pas manqué d’en faire. Mais le mode ligne par ligne ne rentre pas dans une fonction récursive. D’où mon désarroi. A force de relecture, j’ai déjà viré quelques coquilles. Je mets un point d’interruption dans la fonction de lecture d’attribut et en poursuivant l’interprétation à coup de flèche verte, je regarde ce qui se passe dans la fenêtre espion. Donc, si tu as un peut de temps pour me décoincer, ce serai super sympa (une fois de plus) car calculer une branche c’est bien, mais si on arrive à faire l’arbre complet, on duplique l’intérêt de l’outil. Si on arrive à faire tourner (explore, j’ai déjà pas mal d’autres fonctions en tête, une numérotation des bouches, un peuplement automatique des blocs sur un arbre de poly vierge… Bref je suis coincé grave. On pourrait sans doute imaginer parcourir l’arbre directement avec les listes de point (sans se servir de Qa) déjà que je ne m’en sort pas je crois bien que s’eut été encore plus ambitieux. Merci encore si tu es arrivé au bout de ce roman, mais c’est vrai, comme avec monsieur Wolf de pulp fiction, il faut être précis et exhaustif quand on demande de l’aide désespérément à un spécialiste surbooké.

Bon.. je me suis encore mis à la bourre alors que je jetais juste un coup d’œil entre midi et 2...pfff c'est un bouffe temps ces programmes... Je comprend mieux les remarques sur le débogueur, quand on rentre dans une ft récursive, on a plus le pas à pas... bref pour trouver pourquoi ça coince je suis mal... j'ai fait un petit bout de code qui se lance directement, mais il faut avoir le dessin avec les bon bloc pour test Si qq1 pouvais jetter un coup d'oeil et me sortir de la panade je lui en serai très reconnaissant car c'est frustrant de pas comprendre ou est le caffard... le dessin se charge ici http://joch04.free.f...bit-ventil3.dwg et le code c'est ça il manque la partie génération de la branche et la partie traitement à été réduite, mais j'aimerai bien qu'il affiche ""sortie normale de Tex"" apparemment je ne rentre jamais dans (traitebranche) j'y est mi un point d’arrêt et ça arrête pas...pourtant la branche qui part de 0,0 est bien valide, et au pire il devrai calculer les branches terminales mais nada on dirai qu'il ne passe jamais par le cdr ? (defun c:tex (/ ent i in j n lay der sspoly poly lsvtx vtx pt ssblocs lsbloc bloc nombloc hbloc lsbrrecur lsbranche branche tcourant ta QA qc v doc ) (vl-load-com) (setq doc (vla-get-activedocument (vlax-get-acad-object)) ) ;_ Fin de setq (setq lsbrrecur '((("Debit" (0.0 0.0) "3804") ("jonction" (1.0 0.0) "2514") ("Debit" (2.0 0.0) "3811") ("jonction" (3.0 0.0) "2522") ("jonction" (6.0 0.0) "253E") ("jonction" (10.0 0.0) "254C") ) (("Debit" (0.5 1.0) "2B6D") ("Debit" (1.0 1.0) "2B61") ("jonction" (1.0 0.0) "2514") ) (("Debit" (3.0 4.0) "2B55") ("Debit" (3.0 2.0) "2B49") ("jonction" (3.0 0.0) "2522") ) (("Debit" (5.0 2.0) "2B31") ("jonction" (6.0 2.0) "255A") ) (("Debit" (6.0 5.0) "2B3D") ("jonction" (6.0 4.0) "34DA") ("jonction" (6.0 0.0) "253E") ) (("Debit" (8.34004 4.0) "34FE") ("jonction" (6.0 4.0) "34DA") ) ) ) ;_ Fin de setq (explore lsbrrecur) ;; ;; Explore ;; (defun explore (lsbrrecur / brl bloc nok in) (setq brl (car lsbrrecur) in 0 bloc nil nok 0 ) ;_ Fin de setq ;;boucle pour test si un bloc à un QA /=0 (while (< in (length brl)) (setq bloc (nth in brl) hbloc (caddr bloc) ) ;_ Fin de setq (setq Qa (read (Vb-Val-att (handent hbloc) "Qa" ) ;_ Fin de Vb-Val-att ) ;_ Fin de read ) ;_ Fin de setq ;_ Fin de setq (if (and (= 0 Qa) (/= (+ 1 in) (length lsbloc))) ;; test du Qa d'un bloc qui n'est pas le dernier si oui Nok = 1 (setq nok 1) ) ;_ Fin de if (setq in (+ 1 )) ) ;_ Fin de while ;; on sais si la branche est traitable (nok=0) ;; Si Qa non rempli, on ne peut pas calculer la branche ;; on met donc ce bloc à la fin de celle ci et on rappelle explore ;; avec cette nouvelle liste en espérant que le 1er élément soit traitable (if (= nok 1) (progn (setq lsbrrecur (append (cdr lsbrrecur) (list (car lsbrrecur)) ) ;_ Fin de append ) ;_ Fin de setq ;; permutation à (gile) le 1er devient le dernier (explore lsbrrecur) ) ;_ Fin de progn ;;fp ) ;_ Fin de if ;;fi ;; ;; Si Nok = 0 la branche est traitable ;; on traite, suprime cette branche de la collection et relance sur la nouvelle liste (TraiteBranche brl) (if (setq lsbrrecur (cdr lsbrrecur)) (explore lsbrrecur) (print "ggrrrrr") ) ;_ Fin de if ) ;_ Fin de defun ;;;fd explore (print "sortie normale de Tex") ;;; Fin de l'undo (vla-endundomark doc) (princ) ) ;_ Fin de defun ;;fin Vsom ;; ;; Traiement d'une branche et maj Qa ;; (defun TraiteBranche (branche / i u bloc hbloc tcourant ta) (setq i 0 bloc nil ) ;_ Fin de setq (while (< i (length branche)) (setq bloc (nth branche i) hbloc (caddr bloc) ) ;_ Fin de setq (Vb-Mod-att (handent hbloc) "Qa" (rtos 100 )) (setq i (+ 1 i)) ) ;_ Fin de while ;;;fw ) ;fd ;; Vb-Val-att fonction Vlisp pour lire la valeur d'un attribut (defun Vb-Val-att (ent nomatt / att val) ; ent correspond au handel du bloc (codedxf 5) à utiliser comme ça (setq toto (read (Vb-Val-att (handent handle) "REF"))) (foreach att (vlax-invoke (vlax-ename->vla-object ent) 'getattributes ) ;_ Fin de vlax-invoke (and (eq (vla-get-tagstring att) nomatt) ;comme ils disent les fou du code "tournure élégante !" (setq val (vla-get-textstring att)) ; le ET est équivalent à un si dans ce cas là ) ;car on afffecte Val que si att= nom-att bravo Patrick_35 ) ;_ Fin de foreach val ;; retour de fonction ) ;_ Fin de defun ;; fin Vb-Val-att ;; Vb-Mod-att fonction Vlisp pour modifier la valeur d'un attribut ;; à utiliser comme ça (Vb-Mod-att (handent handle) "NIV" new-val) ;; new-val est une string (defun Vb-Mod-att (ent nom-att nval / att inc vblst-att) (setq inc 0 vblst-att (vlax-invoke (vlax-ename->vla-object ent) 'getattributes ) ;_ Fin de vlax-invoke ) ;_ Fin de setq (while (< inc (length vblst-att)) (if (eq (vla-get-tagstring (nth inc vblst-att)) nom-att ) ;_ Fin de eq (vla-put-textstring (nth inc vblst-att) nval) ) ;_ Fin de if (setq inc (+ 1 inc)) ) ;_ Fin de while ) ; ; fin Vb-Mod-att

600mo J'ai l'impression qu'on est à la limite, voire un peu plus loin. J'ai souvenir qu'on peut découper le projet en morceaux .Alors ils appellent ça le travail collaboratif, et comme tout revit, c'est une usine à gaz, mais ça doit permettre de faire des zones sur différent fichiers en en gardant un pour les rassembler tous (bilbo? cette phrase me rappelle quelque chose) Mais de ce que j'ai vu en formation, c'est pas si simple qu'une série d'Xref à concaténer

C'est un peu étrange que ça sorte tout seul, mais ok.. dans mon cas, à la fin de ma fonction Explore, je lance une fonction de traitement, puis supprime l'élément je peut donc faire ça? ... ;; Si Nok = 0 la branche est traitable ;; on traite, supprime cette branche de la collection et relance sur la nouvelle liste (TraiteBranche brl) (if (setq lsbrlocal (cdr lsbrlocal)) (explore lsbrlocal) ) (setq lsbrlocal nil) );; fin de explore Bon... je regarderai ce soir, à force de coder je vais me mettre à la bourre... j'ai un métier moi ! merci pour les info...

you hou!!! j'ai la réponse à une question lisp !!! c'est une première... Alors la fonction qui t’intéresse c'est (strcat si je dis pas de boulette, (strcat "T" (rtos type_APP) "." lettre_APP numero_APP ) il y a un truc avec le type de la 3eme variable que je verrai plutôt string pour faire "02"

je témoigne que ce message est pas suffisamment précis pour ce faire une idée, Une situation contextuelle et une copie d'écran du message eut été bien venue

à 600 mo le projet je ne me pose plus la question... c'est trop tard !! Non... c'est vrai que révit est on ne peut moins économe. Chargez tout il en restera bien quelqu chose !!! Alors, effectivement, je travaille avec le gabari bien chargé jusqu’à la phase Apd, car c'est pratique on a un peu de tout sous la main, puis dès que le projet est ficelé, (début du DCE) je purge tout. Dans ma méthode de travail, je ne me sert de Revit que pour les plans. Si à la purge disparaissent les nomenclatures et autre machin truc cela n'est dans mon cas, pas grave De toute façon, la purge revit supprime surtout les bibliothèques inutilisées (?)

c'est pas fini, mais j'en suis là je vois pas trop pou je mettrai un while.. plutot un exit si je peut pas décrémenter? pour la portée des variables, j'essaye d'être méfiant, mais de toute façon, je manipule plutôt des chaines de liste les vrai variables sont dans les blocs mais j'ai encore un blocage je débugue à la vitesse d'une limace...

:) la première question, je m'y attendais un peu, mais c'est surtout la 2eme qui me travaille. En y réfléchissant, si les 2ft sont définies en dehors, de toute façon comme c'est c: qui appelle F1 qui appelle F2, il devrai pas y avoir de soucis... au passage, un petit rappel svp, comment on sort d'une fonction récursive? je vais passer une liste en argument et la décrémenter à coup de cdr. Mais quand la liste est vide comment je sort?

Oki... reste a savoir quel est le choix le plus judicieux, et je reste indécis dans le cas qui m’occupe... au passage, autre question. si j'ai une fonction F1 définie dans (defun c: et F2 en dehors. F1 peut appeler F2 (?) mais si F1 et F2 sont définies en dehors, F1 peut encore appeler F2 ? Si oui, je fous tout le monde dehors !!

Bonjour par habitude, je regroupe les fonction que j'utilise en dehors du (defun c: ..). (defun toto (arg/ variables) .... ) je lui passe donc des arguments et les variables y restent locale. Mais si la fonction est définie à l'intérieur du (defun c: doit on redéfinir des variables? peut on utiliser les variable du (defun c: qui portent lors sur les 2 fonctions sans pour autant être globale? Merci... :)

On bosse pour un Crous en ce moment...Des travaux réseaux on été fait il y a 5 ans, et un bâtiment s'est fini l'an dernier.Pour notre projet, nous ont été fourni:un plan géomètre de 16 ansEt un relevé "de mémoire" à la main des réseaux sur un fdp géo (16ans) en A3 et qui s'est avéré Alzheimer en phase terminale. De toute façon sans le bâtiment neuf ça pouvais pas coller Pas de DOE du bâtiment ou même plan projet, pas ref des candélabres qu’ils veulent identique... Quand un MO fait pas son taf, on peu lui fournir en fin de chantier les documents qu'il veux, s'il ne les classe pas ou à simplement a la flemme de les sortir, que ce soit BIM ou pas... ça changera rien.On croise parfois des "responsables" dont la responsabilité c'est de te laisser te débrouiller.

En passant, je rage régulièrement sur des relevé topo qui s’arrête à la limite de propriété sans indication du terrain adjacent. Quand on fait un terrassement en limite on aime bien savoir s'il faut un soutènement...Donc c'est une bonne idée de demander qqs pts pour caractériser les abords.Autre lacune courante, les restanques. J'ai souvent, un pts par restanque généralement près du front hautça ne suffit pas il faut un pts en haut et en bas du mur car les restanques étant en pente, impossible d'avoir la hauteur du soutènement autrement qu'au doigts levé d'après photo... En fait, les géomètres continuent de nous vendre une prestation 1912. Il serai temps d'exiger le MNT !

Bon, ben voila ou j'en suis pour cette 3ene version. J'ai chercher à faire une liste de branche ou pour chaque poly je liste les triplets définissant un bloc.Je ne comprends pas encore bien pourquoi il ne veux pas me faire les cercle quand le dernier bloc est pas une jonction (ce qui indique que la poly est à inverser) mais c'est pas bien grave.ce qui reste à faire-réinitialiser les Qauxiliaure de tous les blocs "jonction" pendant la création de la liste - réécrire une fonction Traitebranche qui calcule la branche (et donc renseigne Qauxiliaire sur la dernière jonction ce qui "marque la branche comme finie) ça, je devrai m'en sortir C'est maintenant, que j'aimerai bien qu'un spécialise récurssif ( (gile) si tu traines par là ?) m'aide à faire la fonction qui parcours l'arbre...j'ai du mal à mettre en code cette idée... Merci d'avance... (édit ini de Qa et bug cercle corrigé) (re edit du code..tourne pas...grrr) ;;; Vsom Somme des débits sur un arbre de polylignes V3-2 ;; utile pour la ventil mais facile a adapter ;; Les blocs Debit et jonction sont disponible ici: ;; http://joch04.free.fr/images/vrac/debit-ventil3.dwg ;; cumule les Q dans l'attribut T à l'avancement d'une poly (le point 1 est ;; l'entrée d'air la plus éloignée de la source, le dernier point la source ou jonction ;; chaque branche doit se terminer par une jonction ;; T pour la jonction est la somme de Q branche courante + Q branche auxiliaire ;; dia est le diamètre théorique mini pour une vitesse V (m/s) Q (m3/h) DIA (m) ;; la valeur de V (3 par défaut ) se change en dur au début du code (defun c:vsom (/ ent i j n lay der sspoly poly lsvtx vtx pt ssblocs lsbloc bloc nombloc hbloc lsbranche branche tcourant ta qa qc v doc ) ; initialisation VL (vl-load-com) (setq doc (vla-get-activedocument (vlax-get-acad-object))) (vla-startundomark doc) ; Activer le début de l'undo (setq v 3.0 ;; 3m/s pour un auditorium 5 pour des burreaux voir 6 pour les gros diamètres n 0 ) (setq ent (car (entsel "\nChoix d'une poly du réseau\n")) lay (cdr (assoc 8 (entget ent))) ) ; liste de sélection des poly et blocs du calque (setq sspoly (ssget "X" (list (cons 0 "LWPOLYLINE") (cons 8 lay))) ssbloc (ssget "X" (list (cons 0 "INSERT") (cons 8 lay))) ) ;; création de la liste des bloc lsbloc (pt hadle nombloc) (setq j 0) (repeat (sslength ssbloc) (setq bloc (ssname ssbloc j) ) (setq j (+ 1 j) hbloc (cdr (assoc 5 (entget bloc))) PT (cdr (assoc 10 (entget bloc))) pt (reverse (cdr (reverse pt))) Vba-ent (vlax-ename->vla-object bloc) nombloc (vla-get-effectivename Vba-ent) ) (setq lsbloc (cons (cons nombloc (list pt hbloc)) lsbloc) ) ) ;fr ;;; (print lsbloc) ;;; (print (length lsbloc)) ;;; traitement des poly création de la liste des branches ;;; lsbranche de la forme ( ( nom tp handle1 ) (nom pt handle2) ...) ;;; (setq i 0) (repeat (sslength sspoly) (setq poly (ssname sspoly i) ) (setq lsvtx (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget poly) ) ) ) (princ "\n ") (print lsvtx) (foreach vtx lsvtx (foreach bloc lsbloc (setq pt (cadr bloc)) (if (equal vtx pt 0.02) (setq branche (cons bloc branche)) ;;; réinitialisation des qa des blocs jonctions leur calcul servant de marqueur pour le parcour des branches (if (= "jonction" (car bloc)) (progn (setq hbloc (caddr bloc)) (Vb-Mod-att (handent hbloc) "Qa" 0) ) ;fp ) ;fi ) ;fi ) ;fe bloc ) ;fe vtx (setq branche (reverse branche)) ;; (print branche) (setq nombloc (car (car (reverse branche))) pt (cadr (car (reverse branche))) ) ;; Si le dernier bloc n'est pas une jonction Déssine un cercle, il faudra la retourner (if (/= nombloc "jonction") (progn (entmake (list (cons 0 "CIRCLE") (cons 8 "---EPURES") (cons 62 1) (cons 10 pt) (cons 40 0.5) ) ) (print "attention une poly à invserser") (setq n (+ 1 n)) ) ) ;fi (setq lsbranche (cons branche lsbranche)) (setq i (+ 1 i) branche nil ) ) ;fr Lsbranche prète (if (/= n 0) (progn (alert "Attention il y a des polylignes à inverser") (print n) (exit) ) ) ;;; (print (length lsbranche)) ;;; (foreach branche lsbranche ;;; (print branche) ;;; ) ;; Explore ;; (defun explore (lsbrlocal / brl bloc nok i) (setq brl (car lsbrlocal) i 0 bloc nil brl nil nok 0 ) (while (< i (length brl)) (setq bloc (nth i brl) hbloc (caddr bloc) Qa (read (Vb-Val-att (handent hbloc) "Qa")) ) (if (and (= 0 Qa) (/= (+ 1 i) (length lsbloc))) ;; test du Qa d'un bloc qui n'est pas le dernier si oui Nok = 1 (setq nok 1) ) (setq i (+ 1 )) ) ;;ffe on sais si la branche est traitable (nok=0) ;; Si Qa non rempli, on ne peut pas calculer la branche ;; on met donc ce bloc à la fin de celle ci et on rappelle explore ;; avec cette nouvelle liste en espérant que le 1er élément soit traitable (if (= nok 1) (progn (setq lsbrlocal (append (cdr lsbrlocal) (list (car lsbrlocal)))) ;; permutation à (gile) (explore lsbrlocal) ) ;;fp ) ;;fi ;; ;; Si Nok = 0 la branche est traitable ;; on traite, suprime cette branche de la collection et relance sur la nouvelle liste (TraiteBranche brl) (if (setq lsbrlocal (cdr lsbrlocal)) (explore lsbrlocal) ) ) ;;;fd explore (explore lsbranche) (print "sortie normale de Vsom") ;;; Fin de l'undo (vla-endundomark doc) (princ) ) ;;fin Vsom ;; ;; fonctions ;; ;; ;; Traiement d'une branche et maj Qa ;; (defun TraiteBranche (branche / i u bloc hbloc tcourant ta) (setq i 0 bloc nil ) (while (< i (length branche)) (setq bloc (nth branche i) hbloc (caddr bloc)) (Vb-Mod-att (handent hbloc) "Qa" (rtos 1 ) ) );;;fw ) ;fd ;;;(defun TraiteBranche (branche index / i u bloc qa qc tcourant ta) ;;; ;;; (setq i 0 ;;; bloc nil ;;; ) ;;; (while (< i (length lsbloc)) ;;; ;;; (setq bloc (nth i lsbloc) ;;; nombloc (x" bloc) ;;; hbloc (cadr bloc) ;;; ) ;;; ;;test et mise a jour suivant le cas ;;; (cond ;;; ((= i 0) ;;; (setq ta (read (Vb-Val-att (handent hbloc) "Q")) ;;; tcourant ta ;;; ) ;;; (Vb-Mod-att (handent hbloc) "T" (rtos ta 2 0)) ;;; ) ;;; ;;; ((and (= nombloc "jonction") (/= (+ 1 i) (length lsbloc))) ;;; (setq qa (read (Vb-Val-att (handent hbloc) "Q1")) ;;; ta (+ tcourant qa) ;;; ) ;;; (Vb-Mod-att (handent hbloc) "T" (rtos ta 2 0)) ;;; (Vb-Mod-att (handent hbloc) "Q2" (rtos tcourant 2 0)) ;;; (setq tcourant ta) ;;; ) ;;; ;;; ((and (= nombloc "jonction") (= (+ i 1) (length lsbloc))) ;;; (setq qc (read (Vb-Val-att (handent hbloc) "Qa")) ;;; ta (+ tcourant qa) ;;; ) ;;; (Vb-Mod-att (handent hbloc) "T" (rtos ta 2 0)) ;;; (Vb-Mod-att (handent hbloc) "Q1" (rtos tcourant 2 0)) ;;; (setq tcourant ta) ;;; ) ;;; ;;; ;;; ((= nombloc "Debit") ;;; (setq qa (read (Vb-Val-att (handent hbloc) "Q")) ;;; ta (+ tcourant qa) ;;; ) ;;; (Vb-Mod-att (handent hbloc) "T" (rtos ta 2 0)) ;;; (setq d (rtos (sqrt (/ (* 4 ta) (* pi v 3600))) 2 2) ;;; ;;2 décimales on est en mètre ;;; ) ;;; (Vb-Mod-att (handent hbloc) "DIA" d) ;;; (setq tcourant ta) ;;; ) ;;; (t nil) ;;; ) ;fc ;;; ;;; (setq i (+ 1 i)) ;;; ) ; fw ;;; ;;; ;;;) ;fd ;; Vb-Val-att fonction Vlisp pour lire la valeur d'un attribut ;; (defun Vb-Val-att (ent nomatt / att val); ent correspond au handel du bloc (codedxf 5) à utiliser comme ça (setq toto (read (Vb-Val-att (handent handle) "REF"))) (foreach att (vlax-invoke (vlax-ename->vla-object ent) cv 'getattributes) (and (eq (vla-get-tagstring att) nomatt) ;comme ils disent les fou du code "tournure élégante !" (setq val (vla-get-textstring att)) ; le ET est équivalent à un si dans ce cas là ) ;car on afffecte Val que si att= nom-att bravo Patrick_35 ) val ;; retour de fonction ) ;; fin Vb-Val-att ;; Vb-Mod-att fonction Vlisp pour modifier la valeur d'un attribut ;; à utiliser comme ça (Vb-Mod-att (handent handle) "NIV" new-val) ;; new-val est une string (defun Vb-Mod-att (ent nom-att nval / att inc vblst-att) (setq inc 0 vblst-att (vlax-invoke (vlax-ename->vla-object ent) 'getattributes) ) (while (< inc (length vblst-att)) (if (eq (vla-get-tagstring (nth inc vblst-att)) nom-att) (vla-put-textstring (nth inc vblst-att) nval) ) (setq inc (+ 1 inc)) ) ) ; ; fin Vb-Mod-att ;;;; Fdxf avec effective name VBA (defun Fdxf (entite / lstdxf) ; l'argument et la variable (setq lstdxf (entget entite)) ; liste dxf normale ;;; definition du nom vba de l'entite (setq Vba-ent (vlax-ename->vla-object entite)) ;;; récupération du effectivename et ajout à la lstdxf (setq bdn (vla-get-effectivename Vba-ent)) (setq lstdxf (cons (cons "EffNameBlDyn" bdn) lstdxf)) lstdxf ; le rappel de la variable sans rien sert ;de valeur de retour de la fonction ) ;;

oui, mais le truc basique marche, et avec deux méthodes... ça vaux le coup de pousser un peu la mémé, non? Une première réflexion me démontre que c'est un peu plus compliqué que prévu pour la sélection des branches. j'avance doucement... Et pour l'utilisation de Q2 comme marqueur je sais pas trop il doit y avoir moyen de parcourir une arborescence sans ça. En numérotant les branches? et au passage faire une fonction qui peuple un réseau avec les bloc ad oc en début de conception avec une numérotation automatique des bouches regards etc..... oui.. je m'emballe...

je comprend ton idée, mais je ne suis pas sur que ce soit pratique à l'usage car ça demande pas mal de manip, et c'est difficilement utilisable en conception pour qq1 qui maîtrise pas le programme. (et un des but c'est d'en faire profiter les collègues) L'idée vue là ou on en est, c'est de faire du (defun c: une simple fonction qui parcours l'arbre toute seule le programme principal récursif l'appelant quand il détermine qu'il est sur une branche terminale ou que tous les bloc jonction non final qu'elle comporte ont été marqué (leur Q2 /=0). j'en suis au stade ou c'est moi qui fait la récursivité en cliquant les poly une à une... j'ai regardé l'algorithme de parcours d'un arbre. ( https://fr.wikipedia...s_en_profondeur ) je suis sur qu'il y a moyen de l'adapter C'est peut être une question pour (gile) s'il passe par là. (explorer (poly P jonction J) il y a t il des jonctions intermédiaire non marquée ? oui explorer poly sur la poly dont le dernier sommet est cette jonction non lancer Vsom et donc marquer la poly il faut en amont faire la liste des poly du calque du coup on peu passer directement les points en argument à Vsom faudra que je teste...pour simplifier on va dire que les blocs et la poly sont dans un seul claque je vais tout trier comme ça. Ton idée d'utiliser l'épaisseur, je la garde sous le coude. en dernier recours on fera comme ça. Mais il faudrait trouver moyen d'automatiser sa maintenance et ça revient à trouver une fonction récursive

(rires forts) plus la tête à lire ton code ni éplucher ton message mais le cœur y est, je viens de finir mon idée je la pose et dodo le nouveau bloc est la http://joch04.free.f...bit-ventil2.dwg je sais que c'est pas optimisé, mais l'utilisation de case permet de traiter tous les cas qu'on peu imaginer pour d'autre utilisation, j'ai repiqué le jeu de sélection des blocs avec la méthode de Didier, mais je croyais qu'elle ne sélectionnait que les blocs sur les point mais en fait non, il a quand même fallu trier avec les sommets... pas bien grave je vérifiai ça plus tard... ;;; Vsom Somme des débits sur une polyligne ;; utile pour la ventil Les blocs Debit joncsion sont disponible ici: ;; http://joch04.free.fr/images/vrac/debit-ventil2.dwg ;; cumule les Q dans l'attribut T à l'avancement d'une poly (le point 1 est ;; l'entrée d'air la plus éloignée de la source, le dernier point la source ;; dia est le diamètre théorique mini pour une vitesse V (m/s) Q (m3/h) DIA (m) ;; la valeur de V (3 par défaut ) se change en dur au début du code (defun c:vsom (/ ent i n pt lsvtx vtx ssblocs lsbloc bloc nombloc hbloc tcourant ta qa v) ; initialisation VL (vl-load-com) (setq doc (vla-get-activedocument (vlax-get-acad-object))) (vla-startundomark doc) ; Activer le début de l'undo (setq v 3.0) (setq ent (car (entsel "\nChoix de la polyligne\n"))) (if (= "LWPOLYLINE" (cdr (assoc 0 (entget ent)))) (setq lsvtx (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget ent) ) ) ) (progn (alert "\nNe fonctionne qu'avec une POLYLIGNE") (exit) ) ) ;création de la list des blocs (setq ssblocs (ssget "_f" lsvtx (list (cons 0 "INSERT")))) ;; pas bien compri comment ça marchait ton truc didier (setq i 0) (repeat (sslength ssblocs) (setq bloc (ssname ssblocs i) i (+ 1 i) PT (cdr (assoc 10 (entget bloc))) pt (reverse (cdr (reverse pt))) Vba-ent (vlax-ename->vla-object bloc) nombloc (vla-get-effectivename Vba-ent) ) (foreach vtx lsvtx (if (equal vtx pt) (setq lsBloc (append lsBloc (list (cons nombloc (cons (cdr (assoc 5 (entget bloc))) pt ) ) ) ) ) ) ) ;ff ) ;fr ;fin setq lsbloc contient le nom du bloc le handle et une paire X/Y ;; Traiement des blocs (setq i 0 bloc nil ) (while (< i (length lsbloc)) (setq bloc (nth i lsbloc) nombloc (car bloc) hbloc (cadr bloc) ) ;;test et mise a jour suivant le cas (cond ((= i 0) (setq ta (read (Vb-Val-att (handent hbloc) "Q")) tcourant ta ) (Vb-Mod-att (handent hbloc) "T" (rtos ta 2 0)) ) ((and (= nombloc "jonction") (/= (+ 1 i) (length lsbloc))) (setq qa (read (Vb-Val-att (handent hbloc) "Q1")) ta (+ tcourant qa) ) (Vb-Mod-att (handent hbloc) "T" (rtos ta 2 0)) (Vb-Mod-att (handent hbloc) "Q2" (rtos tcourant 2 0)) (setq tcourant ta) ) ((and (= nombloc "jonction") (= (+ i 1) (length lsbloc))) (setq qa (read (Vb-Val-att (handent hbloc) "Q2")) ta (+ tcourant qa) ) (Vb-Mod-att (handent hbloc) "T" (rtos ta 2 0)) (Vb-Mod-att (handent hbloc) "Q1" (rtos tcourant 2 0)) (setq tcourant ta) ) ((= nombloc "Debit") (setq qa (read (Vb-Val-att (handent hbloc) "Q")) ta (+ tcourant qa) ) (Vb-Mod-att (handent hbloc) "T" (rtos ta 2 0)) (setq d (rtos (sqrt (/ (* 4 ta) (* pi v 3600))) 2 2) ;;2 décimales on est en mètre ) (Vb-Mod-att (handent hbloc) "DIA" d) (setq tcourant ta) ) (t nil) ) ;fc (setq i (+ 1 i)) ) ; fw (print "sortie normale de Vsom") (princ) ) ;;fin Vsom ;; ;; fonctions ;; ;; Vb-Val-att fonction Vlisp pour lire la valeur d'un attribut (defun Vb-Val-att (ent nomatt / att val); ent correspond au handel du bloc (codedxf 5) à utiliser comme ça (setq toto (read (Vb-Val-att (handent handle) "REF"))) (foreach att (vlax-invoke (vlax-ename->vla-object ent) 'getattributes) (and (eq (vla-get-tagstring att) nomatt) ;comme ils disent les fou du code "tournure élégante !" (setq val (vla-get-textstring att)) ; le ET est équivalent à un si dans ce cas là ) ;car on afffecte Val que si att= nom-att bravo Patrick_35 ) val ;; retour de fonction ) ;; fin Vb-Val-att ;; Vb-Mod-att fonction Vlisp pour modifier la valeur d'un attribut ;; à utiliser comme ça (Vb-Mod-att (handent handle) "NIV" new-val) ;; new-val est une string (defun Vb-Mod-att (ent nom-att nval / att inc vblst-att) (setq inc 0 vblst-att (vlax-invoke (vlax-ename->vla-object ent) 'getattributes) ) (while (< inc (length vblst-att)) (if (eq (vla-get-tagstring (nth inc vblst-att)) nom-att) (vla-put-textstring (nth inc vblst-att) nval) ) (setq inc (+ 1 inc)) ) ) ; ; fin Vb-Mod-att ;;;; Fdxf avec effective name VBA (defun Fdxf (entite / lstdxf) ; l'argument et la variable (setq lstdxf (entget entite)) ; liste dxf normale ;;; definition du nom vba de l'entite (setq Vba-ent (vlax-ename->vla-object entite)) ;;; récupération du effectivename et ajout à la lstdxf (setq bdn (vla-get-effectivename Vba-ent)) (setq lstdxf (cons (cons "EffNameBlDyn" bdn) lstdxf)) lstdxf ; le rappel de la variable sans rien sert ;de valeur de retour de la fonction ) ;;

j'ai bien compris, mais à moins d'automatiser le calcul de réseau complet (et de réinitialiser les T a chaque mise a jour) , ça va être fastidieux de devoir tout reprendre en cas de modif sur une branche (et des modifs yana 10 par jour en conception). Un réseau courant, c'est vite deux ou 3 branches par étage, encore un problème plus facile a régler avec un bloc de jonction qui renvoie à un autre graphe. C'est un peu tard, mais je tente un truc.

plop... révélation... c'est pire que prévu. le bloc de jonction ne peut pas être le même que le bloc des bouches. En effet, on a en ce point besoin de 3 débit. La branche 1, le collecteur, et le total. quand la jonction est en fin de branche, on doit totaliser sur Q1, si le bloc n'est pas le dernier on reporte le T précédent dans Q2 et la sortie T fait la somme de Q1+Q2. On modélise un T, c'est donc logique qu'il y ai 2 débits d'entrée. édit... je viens de comprendre comment tu veux te passer de cette modélisation "réaliste" du T en traitant les réseaux dans l'ordre... une fois de plus, très malin... je vais tester. Après tout si au départ de la procédure on remet à 0 tous les T pourquoi pas... à voir. Mais dans mon idée de faire un truc modulaire, je suis pas fan s'il faut recalculer toutes les branches pour n'en avoir changé qu'une seule.. bof. a moins de trouver le moyen de lancer la routine sur un calque car chaque réseau à son calque donc toutes les poly qui y sont présentes en font partie. Et puis je reviens aussi sur le traitement à l'avancement des débits dans la même boucle. Avec cet algorithme, quand on calcule Tn, le bloc n+1 n'est pas encore déterminé. Si je veux pouvoir adapter la routine à des calculs de pente ça va être gênant.. Il peut être pratique d'avoir accès à un bloc amont je vais sans doute rester sur 2 boucles, même si c'est moins efficace informatiquement parlant. décidément c'est pas trivial pour sortir un cas général. Si ça me travaille trop je regarde de plus près ce soir....

la vache que c'est beau... j'ai épluché ton code, même si à 1ere vue l'algo semble similaire, à la fin comme tu balances tous les calculs dans la même boucle avec un if ça déchire. Mais dans cette partie d'échec collaborative, je reste sur mon idée. Tester T=0 ne marche pas en cas de modif d'un réseau T aura déja été attribué avant. Et si dans la branche qu'on est en train de parcourir on rencontre un Q=0, comment savoir si c'est un coude, un filtre, ou une jonction pour qui la variable à ajouter est T et plus Q sans un attribut de plus. bon je rogne sur la sieste... je m'y replongerai ce soir.... si ce module marche pile poil, on devrai pouvoir utiliser la récursivité pour sélectionner toutes les poly d'un calque. Mais j'ai jamais réussi à comprendre comment on parcourrai une arborescence. ce sera peut être l’occasion d'enfin piger le truc.