somme des débits

[x_all]

Bonjour

 

je cherche un lisp qui fait la somme des débits sur une ligne de ventil

typiquement, je trace une polyligne et à chaque sommet il y a un bloc avec 2 attributs Q et T. Q est le débit de la bouche, et T est le total des débits à l'avancement (Q1+Q2... )

 

Alors je ne cherche pas à faire plusieurs branche, mais une seule poly à la fois, typiquement il faut sommer les bouches de la dernière à la fin de la branche au sommet 0 ou on place ou met à jour le bloc qui indique le total des débits...

 

Je me doute que c'est pas hyper simple, mais si qq1 à un truc qui traine dans le genre ça me ferai gagner un temps fou (temps que j'ai pas pour mouliner le code et temps que je perd à recalculer mes conduite et à faire des boulettes)

 

merci pour les courageux du vendredi :)

[didier]

Coucou

 

C'est clairement le type de question qui demande un DWG exemple pour être certain de taper juste

Je ne dis pas que c'est mal expliqué, c'est même plutôt bien,

Mais avec les blocs il y a des subtilités et face au DWG on peut discuter.

Avant que tu nous refasses un message sur l’impossibilité de déposer un fichier sur le site sache que tu devras passer par wetransfer ou autres, enfin de l'externe...

Amicalement

[GEGEMATIC]

Salut,

j'ai plusieurs chose du même acabi,

mais trop complexes pour en faire un package et le partager.

 

dans certain cas, je renonce à l'automatisme total, car avec les histoires de noaud au sommet d'une polylignes, tu peu vite avoir des pb

je fais mon addition manuellement en sélectionnant les blocs, et en inserrant un bloc en faisant la somme.

c'est beaucoup plus simple, très accessibles avec les codes que tu peux trouver sur ce forum.

a+

Gégé

[x_all]

Merci de vos attentions, je pose un lien ver un fichier d’exemple:

 

https://www.dropbox....ventil.dwg?dl=0

 

Les blocs sont posé aux sommets de la polyligne, il y a un attribut supplémentaire pour faire une prédim du diamètre ou de la section que je calculerai avec un champ en fonction de la vitesse max souhaitée, mais c'est juste de la prédim (pas de tableau de diamètre juste je calculerai un diamètre mini)

Le dernier bloc est à Q=0 car ce n'est pas une bouche , mais soit la machine soit une jonction de branche.

 

Je ne cois pas qu'algorithmiquement parlant ce soit super compliqué, car je ne souhaite pas cumuler une arborescence avec des jonctions de branche pour justement faire un utilitaire simple qui oblige à continuer à utiliser son cerveaux. Car comme le souligne GEGE, ça peut vite devenir une usine a gaz un réseau de ventil.

En l'espèce, un tel utilitaire cumule une branche si je veux mettre à jour la suivante, ce sera à moi de ne pas oublier...

 

Donc pour des blocs de 0 à n, on a Tn=Qn+Tn-1. Par habitude j'ai tendance à faire les poly de la source vers l'extrémité, mais s'il faut les inverser c'est pas bien grave.

 

Ce qui me pose pb, c'est comment traduire ça en lisp, comment identifier les blocs, car même s'ils ont le point d'insertion est sur un sommet de la poly comment on le récupère?

 

Dans l'idéal, on lance la fonction il demande la polyligne à traiter et il met à jour les T, point barre.

 

OUPS!!!!!!!!!!!!

Sur le fichier je me rend compte qu'il y a une boulette, le dernier T devrai être à 100 et pas 125 !! (quand je dis que c'est la plaie à faire des cumul...)

je met le dwg à jour, mais si qq1 l'a déja chargé...

[x_all]

Bonjour...

je relance un peu le sujet...J'ai un peu de temps ce matin, du coup je déterre un peu le post...Je suis en train de regarder le code pour la routine, effectivement je devrai m'en sortir pour les sommes, mais j'ai du mal pour la sélection de bloc.

Comment faire pour récupérer les blocs dont le point d'insertion est sur un sommet de la polyligne sélectionné (et dans le bon ordre)

merci

 

[didier]

Coucou

 

J'ai commencé un truc pour toi mais je manque de temps

Il va falloir faire un jeu de sélection (facile)

Faire une liste avec les noms d'entités et les coordonnées(pas très compliqué)

Faire une comparaison avec les sommets de la polyligne (en espérant qu'elle est dessinée dans le bon sens)

Et voila

J'ai avancé un peu et j'aurai un peu de temps libre mais pas avant la semaine prochaine.

 

Nota : le dessin que tu as donné réserve des surprises : les blocs sont en "anonyme" dans la définition de l'entité, pas cool les copier-coller

Amicalement

[x_all]

^^

les blocs ne sont pas anonymes, mais dynamiques (pour pouvoir repositionner l'étiquette)

j'avais fait un truc pour s'en sortir, je essayé de retrouver mes petits ( http://joch04.free.f...ps-bloc-dyn.htm ) c'est une histoire d'EffectiveName les blocs dynamiques imposent de passer par les fonctions Vba

 

c'est pour le jeu de sélection que je cale. Dans mon idée, on sélectionne la poly, et de la poly, il faut que je récupère les sommets puis récupèrer les blocs dont le point d'insertion est sur les sommets...

 

bref, mon soucis, c'est surtout de faire une liste de bloc à partir d'une liste de sommets de poly...après je devrai m'en sortir

Ps si la poly est pas dans le bon sens, je l'inverserai c'est pas bien grave...

[Olivier Eckmann]

Bonjour,

 

Si tu n'as pas trop de bloc (quelques centaines) pour chaque sommet de polyligne, tu peux calculer la distance entre ce sommet et chacun des blocs. Quand la distance = 0 c'est bon. Attention la fonction Distance calcule en X Y et Z, donc si tes blocs n'ont pas le même Z que ta poly, la distance ne sera pas nulle. Par sécurité, il faut programmer une fonction de distance 2D.

Pour le parcours des blocs, soit tu parcours directement le jeu de sélection et tu extrais le code 10 à chaque fois, soit tu crées une liste de paire pointée Handle / Coordonnées en parcourant 1 fois tes blocs au début.

(cons (cdr (assoc 5 (entget oBloc))) (cdr (assoc 10 (entget oBloc))))

 

Tu parcours la liste pour calculer tes distances et quand c'est 0 tu retrouves ton bloc à partir du handle via la fonction

(handent )

Pour gagner un peu de temps tu fais tous tes calculs sur la distance au carré ce qui évite de calculer une racine carrée (gourmande en temps machine)

 

Olivier

[x_all]

ho punaise quand on pratique pas on oublie tout

J'ai commencé le bousin, mais j'ai une boulette que j’arrive pas à savoir d'ou ça vient...

Je fait la liste des blocs du dessin, puis je trie les bloc "Debit" pour n'avoir à traiter que les blocs qui m’intéressent. Mais je me retrouve avec la liste des bloc en double... pourquoi?

je pressent une boulette classique de débutant, mais je la trouve pas.

(à la fin du code les print sont là pour test (et c'est là que j'ai des doublons...

 

;;; Vsom Somme des débits dans les bloc 'Debit' qui se trouvent aux sommets de la poly


(defun c:vsom (/ axe pt lst-bloc mod ss ent i n lstdxf lst-pt)

				; 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	lst-bloc nil
lst-pt     nil
axe     nil
mod     0.01
ss     (ssget "_X" '((0 . "INSERT")))
				;selectiond de tous les blocs du dessin
i     0
n     0
 )

 ;; 1er test pour voir si les conditions sont bonnes                          	
 (if (= nil ss)
(progn
 	(print " Pas de blocs exploitable sortie du programme")
 	(quit)
)

 )


 ;; dans cette boucle, on va créer une liste de travail (lst-bloc)  avec les liste dxf des blocs qui nous intéressent   
 (repeat (sslength ss)
(setq ent (ssname ss i))		; ent est l'entité placée en position i du selection-set ss
(setq lstdxf (fdxf ent))		; je stoke dans lstdxf la valeur de retour de la fonction fdxf pour l'élément ent

;; trier les bloc Debit   
(cond ((= (cdr (car lstdxf)) "Debit")
				; début de la liste des conditions et 1er test:    	
      (setq lst-bloc (cons lstdxf lst-bloc)
				;Si c'est un débit on le stoke dans la liste de travail   
     n  	(1+ n)	;(compte les bloc valide
      )
 	)
)					; fin du cond
(setq i (1+ i))			; incrément pour parcours de lstdxf
 )
;;; fin repeat liste des bloc débit du dessin est prète
;;;

 (if (= 0 n)
(progn
 	(print
" Pas de blocs 'Debit' exploitable sortie du programme"
 	)
 	(quit)
)
 )


				; choix de l'axe et liste des points
 (setq axe (entsel "\nSélectionner l'AXE de la conduite à traiter "))
 (setq axe (entget (car axe)))
 (foreach pt (vl-remove-if-not
	'(lambda (x) (eq (car x) 10))
	axe
 		)
(setq lst-pt (cons pt lst-pt))
 )

 ;; liste des blocs sur la poly
;;;  (setq	ss list-bloc
;;;	i  (sslength list-pt)
;;;  )
;;;  (while (> i 0)
;;;	(setq pt)
;;;
;;;
;;;  )


 (print lst-pt)
;  (print lst-bloc)

 (print (assoc 10 (car lst-bloc)))



















 
)					;fin Vsom








;;                                                                           		
;;                       		fonctions                                   		
;;                                                                           		

;; Vb-Val-att fonction Vlisp pour lire la valeur d'un attribut
(defun Vb-Val-att (ent nomatt / att val)
 (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
(defun Vb-Mod-att (ent nomatt Nval / att)
 (foreach att
      (vlax-invoke (vlax-ename->vla-object ent) 'modattributes)
(and (eq (vla-get-tagstring att) nomatt)
    (vla-put-textstring
      (nth	0
	(vlax-invoke (vlax-ename->vla-object ent) 'modattributes)
      )
      nval
    )
)
 )
)					; 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
)

[x_all]

ho punaise !!!j'ai oublier le princ à la fin, ce qui fait que j'ai deux fois le dernier print...

grrrrrr en fait , ça marche...

pour info, j'ai bien mes listes, demain je fait les attribut, mais ça devrai être moins compliqué

Juste en passant, dans le dernier test, je vérifie qu'il y a bien autant de bloc que de sommets de la poly, ça marche, mais si je provoque une erreur j'ai un salle message pas contant

pourquoi diable?

Commande: VSOM

Sélectionner l'AXE de la conduite à traiter

" le nombre de bloc débit est différent du nombre de sommets de la poly"

Impossible d'appeler (command) à partir de *error* sans appeler préalablement (*push-error-using-command*).

Il est recommandé de convertir les appels (command) en (command-s).

 

 

 

 

;;; Vsom Somme des débits sur une polyligne





(defun c:vsom (/ axe pt lst-pt ss ent i n lstdxf lst-bloc bloc posi)

				; 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	lst-bloc nil
lst-pt 	nil
axe 	nil
ss 	(ssget "_X" '((0 . "INSERT")))
				;selectiond de tous les blocs du dessin
i 	0
n 	0
 )


 ;; dans cette boucle, on va créer une liste de travail (lst-bloc)  avec les liste dxf des blocs qui nous intéressent   
 (repeat (sslength ss)
(setq ent (ssname ss i))		; ent est l'entité placée en position i du selection-set ss
(setq lstdxf (fdxf ent))		; la fonction fdxf a été boostée pour contenir l'effectivename du bloc dynamique (on cherche Debit)

;; trier les bloc Debit   
(cond ((= (cdr (car lstdxf)) "Debit")
				; début de la liste des conditions et 1er test:    	
  	(setq lst-bloc (cons lstdxf lst-bloc)
				;Si c'est un débit on le stoke dans la liste de travail   
    	n  	(1+ n)	;;;compte les bloc valides
  	)
 	)
)					; fin du cond
(setq i (1+ i))			; incrément pour parcours de lstdxf
 )
;;; fin repeat liste des bloc débit du dessin est prète
;;;

 (if (= 0 n)
(progn
 	(print
" Pas de blocs 'Debit' exploitable sortie du programme"
 	)
 	(quit)
)
 )


				; choix de l'axe et liste des points
 (setq axe (entsel "\nSélectionner l'AXE de la conduite à traiter "))
 (setq	axe (entget (car axe))
 )
 (foreach pt (vl-remove-if-not
	'(lambda (x) (eq (car x) 10))
	axe
 		)
(setq lst-pt (cons pt lst-pt)                                                            	;;lst-pt est la liste des points de la poly

)
 )

 ;; liste des blocs sur la poly                                                   				
 (setq ss lst-bloc)
 (setq	i (length ss)
lst-bloc nil
 )

 (while (> i 0)
(setq bloc (car ss))
(setq i  (- i 1)
 	ss (cdr ss)
)
(foreach pt	lst-pt
 	(setq posi (assoc 10 bloc)
	posi (reverse (cdr (reverse posi)))                  ;;;;astuce à (gile) pour virer le dernier élément d'une liste (la coordonnée z) un cdr qui part de la fin.
 	)
 	(if (equal pt posi)
(setq lst-bloc (cons bloc lst-bloc))        ;;; si le bloc est sur la poly, on l'ajoute à la liste
 	)
)
 )					; fin while
;;test pour vérifier que tous les sommets sont atribués
 (if (/= (length lst-bloc) (length lst-pt))
(progn
 	(print
" le nombre de bloc Debit est différent du nombre de sommets de la poly sortie du programe"
 	)
 	(quit)
)
 )
  
 (reverse lst-bloc)                                                             	;;;;pour les mettre dans le même sens que la poly
 (print lst-bloc)






 (princ)
)					;fin Vsom








;;                                                                   				
;;               				fonctions                           				
;;                                                                   				

;; Vb-Val-att fonction Vlisp pour lire la valeur d'un attribut
(defun Vb-Val-att (ent nomatt / att val)
 (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
(defun Vb-Mod-att (ent nomatt Nval / att)
 (foreach att
  	(vlax-invoke (vlax-ename->vla-object ent) 'modattributes)
(and (eq (vla-get-tagstring att) nomatt)
	(vla-put-textstring
  	(nth	0
	(vlax-invoke (vlax-ename->vla-object ent) 'modattributes)
  	)
  	nval
	)
)
 )
)					; 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
)



;;   

[didier]

Coucou

 

J'ai trouvé un peu de temps et j'ai fait ça :

 

(defun c:xall ( / ent sommetsliste n const jeublocs t1 t2)
(setq ent (car (entsel "\nChoix de la polyligne\n")))
(if (= "LWPOLYLINE" (cdr (assoc 0 (entget ent))))
 (setq sommetsliste (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget ent))))
 (progn
(alert "\nNe fonctionne qu'avec une POLYLIGNE")
(exit)
)
 )
(setq n 0 const 25)

(setq jeublocs (ssget "_f" sommetsliste (list (cons 0 "INSERT"))))
(repeat (sslength jeublocs)
 (setq t1 (entnext (entnext (ssname jeublocs n))))  
 (setq t2 (subst (cons 1 (itoa const)) (assoc 1 (entget t1)) (entget t1)))
 (entmod t2)
 (entupd t1)
 (setq n (1+ n))
 (setq const (+ 25 const))
 )
 )

 

Tu me tiens au courant s'il te plaît

 

Amicalement

[didier]

Coucou

 

Ce que j'ai écrit est assez "simple" mais la simplicité est souvent une bonne chose

Toutefois, il n'y a pas de contrôle de nombre de blocs et de sommets, assez simple à mettre en place

On peut assurer le coup en faisant un zoom sur l'objet polyligne pour être certain que le sélection soit correcte mais si elle n'est pas trop longue ça fonctionne, j'ai testé avec 25 sommets, OK, et pas des sommets forcément alignés

On peut aussi faire un texte visible à l'écran du style 1 2 3 4 ... aux endroits des attributs modifiés pour faire un rapide contrôle visuel

En faisant un ssget "à la volée" de ces textes, l'utilisateur les supprimera sur une simple validation su style : OK pour l'ordre, valid effacement une autre touche on annuleir tout.

Enfin, tu connais le lisp, tu as un site dédié toi aussi donc on parle en connaissance.

 

Amicalement

[x_all]

oki... je teste ..

en 1ere lecture je comprend pas tout...pourquoi setq const 25?

quand je voie la concision du code je reste sans voix car je ne peu m’empêcher d'en faire des caisses...

il y a effectivement pas trop de controle, mais bon c'est pas hyper grave ya q'a faire gaffe, mais quand on fait ce genre de truc à la pogne on y passe des heures (et à la fin l'archi change les effectifs et donc je doit me retaper tous les débits)

bref ça va m'aider

au passage, je cherche à faire une fonction ''universelle'' pour modifier un attribut dans un bloc quelconque avec un appel du type(Vb-Mod-att (handent handle) "non de l'attribut" (rtos nouvelle valeur 2 0)) ;; pour les m3/h je vire les décimales

 

je suis arrivé à ça:si tu as de commentaires... ou un moyen de raccourcir :)

 

;;  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))
 )
)

[x_all]

bon après test je vois d'ou vient le 25... mais le pb c'est que c'est pas forcément 25 la valeur de départ...et pour la suite pareil, il ne collecte pas la valeur des attribut pour incrémenter le total...

mais bon... de mon coté aussi, j'ai pas mal avancé et pour tout dire bientot fini (ça tombe bien que j'avais finalement 2 jour (rires forts))

il ne me reste plus qu'une modif pour trier les blocs car ils arrivent pas forcément dans l'ordre des points.

Avec la version postée au message 10, je cherche dans la collection de bloc celui qui colle au vertex, en fait si je veux respecter l'ordre, il faut que je fasse le contraire, chercher a partir des vertex quel bloc à les même X/Y

... et comme ça je suis forcément dans l'ordre

je poste quand j'ai fini, car c'est une routine qui devrai être adaptable à pas mal de truc.. voire même, mais ce sera pour une autre fois, à calculer les chutes de tentions en ft de la longueur du câble...

[x_all]

boulala c'est laborieux...mais ça marche... enfin il faudrait améliorer la détection de la position en y ajoutant une tolérence car si c'est trop grand, il me dit que je ne suis pas bien accroché (edit ayé)

 

à suivre, mais là il faut que je bosse un peu quand même... avant le wiki...

;;; Vsom Somme des débits sur une polyligne                                                	
;; utile pour la ventil Le bloc Debit est disponible ici:                                  	
;; http://joch04.free.fr/images/vrac/debit-ventil.dwg (3 attributs obligatoires Q T et DIA)	
;; 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 (/  	axe	pt		lst-pt ss  	ent 	i	n
  		lstdxf lst-bloc		bloc   qa  	ta 	handle	posi
  		v d
 		)

				; 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	lst-bloc nil
lst-pt nil
axe nil
v 3.0  ;; 3m/s pour un auditorium 5 pour des burreaux voir 6 pour les gros diamètre
i 0
n 0
qa 0
;;selection  de tous les blocs du dessin  	
ss
	(ssget "_X" '((0 . "INSERT")))

 )




 ;; dans cette boucle, on va créer une liste de travail (lst-bloc)  avec les liste dxf des blocs qui nous intéressent   
 (repeat (sslength ss)
(setq ent (ssname ss i))		; ent est l'entité placée en position i du selection-set ss
(setq lstdxf (fdxf ent))		; la fonction fdxf a été boostée pour contenir l'effectivename du bloc dynamique (on cherche Debit)

;; trier les bloc Debit   
(cond ((= (cdr (car lstdxf)) "Debit")
				; début de la liste des conditions et 1er test: 		
  	(setq lst-bloc (cons lstdxf lst-bloc)
				;Si c'est un débit on le stoke dans la liste de travail   
    	n  	(1+ n)
;;;compte les bloc valides
  	)
 	)
)					; fin du cond
(setq i (1+ i))			; incrément pour parcours de lstdxf
 )
;;; fin repeat liste des bloc débit du dessin est prète
;;;

 (if (= 0 n)
(progn
 	(print
" Pas de blocs 'Debit' exploitable sortie du programme"
 	)
 	(exit)
)
 )

 ;; 	choix de l'axe et liste des points                              	

 (setq axe (entsel "\nSélectionner l'AXE de la conduite à traiter "))
 (setq	axe (entget (car axe))
 )
 (foreach pt (vl-remove-if-not
	'(lambda (x) (eq (car x) 10))
	axe
 		)
(setq lst-pt (cons pt lst-pt)
    	;;lst-pt est la liste des points de la poly
)
 )

 ;; liste des blocs sur la poly                                                                            	
 (setq ss lst-bloc)
 (setq	i 	(length lst-pt)
lst-bloc nil
 )

 (foreach pt lst-pt
(foreach bloc ss
 	(setq posi (assoc 10 bloc)
	posi (reverse (cdr (reverse posi)))
 	)
;;;;astuce à (gile) pour virer le dernier élément d'une liste (la coordonnée z) un cdr qui part de la fin.
 	(if (equal pt posi 0.02)
;; tolérence pour la position, sans ça sur les grands dessin ça merdoi 
(setq lst-bloc (cons bloc lst-bloc))
 	)
)
 )					; fin FE
 ;;test pour vérifier que tous les sommets sont atribués
 (if (/= (length lst-bloc) (length lst-pt))
(progn
 	(print
" le nombre de bloc Debit est différent du nombre de sommets de la poly sortie du programe"
 	)
 	(exit)
)
 )


;;;;;;;;;;;;                            	Calculs et maj attributs          	
 (Setq	i  	1
handle (cdr (assoc 5 (car lst-bloc)))
qa 	(read (Vb-Val-att (handent handle) "Q"))
 )
 ;; mise à jour du 1er bloc
 (Vb-Mod-att (handent handle) "T" (rtos qa 2 0))
				;                	pas de décimales ( m3/h)  à changer pour un autre usage

 ;;                 				traitement de la suite de la poly          	

 (while (< i (length lst-bloc))
(setq bloc 	(nth i lst-bloc)
 	handle (cdr (assoc 5 bloc))
 	ta 	(+ qa (read (Vb-Val-att (handent handle) "Q")))
)
(Vb-Mod-att (handent handle) "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 handle) "DIA" d)

(setq i  (+ i 1)
 	qa ta
)
 )








 (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
)



;;  

[didier]

Coucou

 

La constante c'est parce qu'il me semblait avoir compris qu'on augmentait de 25 par bloc, je ne sais pas du tout de quoi on parle en l'occurrence.

Je n'ai pas compris le cumul à la fin non plus mais tu devrais t'en sortir

J'ai juste écrit ça pour "montrer" qu'il ne faut pas des lignes et des lignes pour être efficace

À mes débuts "on" disait qu'une routine lisp devait faire six lignes, aujourd'hui la tendance est à l'obésité.

À ta disposition si tu en veux plus.

Amicalement

[x_all]

c'est comme je le disais pour m'aider au dimentionnement (ou au moins la prédim) des gaines de ventilations

sur un collecteur, il a des bouches de ventil (je schématise) chaque bouche à un débit qui lui est propre, à la fin du collecteur, il faut savoir quel est le débit total.à l’avancement, les débits se cumulnte. Donc dans le collecteur, suivant la vitesse tolérée il faut changer le diamètre du collecteur car Q=Vs et comme la vitesse limite est fixe, il faut augmenter la section quand le débit change...

Le soucis, c'est qu'un collecteur à rarement une seule branche. avec ce ptit programme, on ne calcule qu'une seule branche. (ça va déja bien me faire gagner du temps)si tu veux un exercice, chalenge, c'est comment traiter plusieurs branches !!

je crois pas qu'on puisse se passer d'un attribut supplémentaire qui définisse si le bloc est une jonction de branche ou simplement une bouche. Et puis ça doit sans doute être un cas type pour la récursivité, bref une belle galère...

J'ai mis à jour le code pour y inclure la prédim du diamètre et qqs commentaires (car sans ça dans 6 mois je comprend plus rien a rien) tant pi pour le boulot, si la semaine est pas gagne c'est trop tard...

quand à un code concis.... ben il y a surement moyen d'améliorer, mais en l'espèce ya quand même pas mal de trucs à faire... mais je suis preneur pour un réécriture orthodoxe :)

 

[didier]

Coucou

 

Je ne t'ai pas demandé de cours de climatisation ou de ventilation ! (je te parle de géodésie, moi ? (hihi))

Le souci quand on "travaille" hors de son domaine de compétence c'est qu'on fait des impasses.

La constante de 25 en est l'exemple, je voulais juste avoir une valeur à ajouter

 

Amicalement

[Olivier Eckmann]

Bonjour,

 

ci-joint une version du programme qui cumule les débits y compris sur réseau ramifié.

 

(defun C:SomDebit ( / JEU I J lsBloc oBloc PT oPoly lsVtx Vtx sHndProche sHnd dDist dDistMin dDistMaxRecherche iTotal iDebit)
 (setq dDistMaxRecherche 0.01)
 ; sélection des blocs avec attribut
 (if (setq JEU (ssget (list (cons 0 "INSERT") (cons 66 1))))
   (progn
     (setq I 0)
     ; création de la liste des paires pointées (Handle . Point)
     (repeat (sslength JEU)
(setq oBloc (ssname JEU I))
(setq I (1+ I))
(setq PT (cdr (assoc 10 (entget oBloc))))
(setq lsBloc (append lsBloc (list (cons (cdr (assoc 5  (entget oBloc)))
				        (list (list (car PT) (cadr PT) 0.0))
				  )
			    )
	     )
)
     )
     ; sélection de la polyligne
     (while (and (setq oPoly (car (entsel "\nSélectionner la polyligne : ")))
	  (= "LWPOLYLINE" (cdr (assoc 0 (entget oPoly))))
     )
   	(setq lsVtx (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget oPoly))))
(setq I 0)
(setq iTotal 0)
; boucle sur les Sommets
(repeat (length lsVtx)
  (setq Vtx (nth I lsVtx))
  (setq I (1+ I))
  (setq Vtx (list (car Vtx) (cadr Vtx) 0.0))
  (setq sHndProche nil)
  (setq dDistMin 1000000.0)
  ; boucle sur la liste des blocs pour trouver celui superposé au sommet
  (setq J 0)
  (while (and (< J (length lsBloc))
	      (>= dDistMin dDistMaxRecherche)
	 )
    (setq sHnd (car (nth J lsBloc)))
    (setq PT (cadr (nth J lsBloc)))
    (setq J (1+ J))
    (setq dDist (distance PT Vtx))
    (if (and (< dDist dDistMin)
	     (< dDist dDistMaxRecherche)
	)
      (setq dDistMin dDist
	    sHndProche sHnd)
    )
  )
  ; teste si bloc trouvé
  (if (not sHndProche)
    ; si bloc non trouvé ALORS dessine un cercle rouge calque 0
    (entmake (list (cons 0 "CIRCLE")
		   (cons 8 "0")
		   (cons 62 1)
		   (cons 10 Vtx)
		   (cons 40 0.5)
	     )
    )
    ; si bloc trouvé ALORS met à jour l'attribut T avec Q pour 1er bloc sinon Q+T précédent
    (progn
    (setq iDebit        (atoi (Vb-Val-att (handent sHndProche) "Q")))
    (setq iTotalCourant (atoi (Vb-Val-att (handent sHndProche) "T")))
    (if (= iTotalCourant 0)
      (setq iTotal (+ iTotal iDebit))
      (setq iTotal (+ iTotal iTotalCourant))
    )
    (Vb-Mod-att (handent sHndProche) "T" (itoa iTotal))
    )
  )
)
     )
     
   )
 )
)

    
;;                                                                                              
;;                                              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 

    

 

 

Je joins un screencast de la procédure : il faut au départ que tous les attributs T soient sur 0 , puis il faut cliquer chaque branche de l'amont vers l'aval.

 

Olivier

[x_all]

ho punaise...!!

des bricolages maison vont m' occuper tout le wiki, mais la lecture de ton code m'enchante... ça à l'air super prometteur... je visualise bien mes lacunes et pertes de temps.. heureusement que j'ai pas à traiter des gros paquets de données car je gaspille les temps de calcul avec mes algo à 2 balles... ça promet d’être super efficace j'ai hâte d'avoir du temps à y consacrer

 

merci

 

ps,

par contre, pour traiter plusieurs branches, il me semblait qu'on ne pouvais se passer d'un attribut supplémentaire pour déterminer si le bloc était une jonction. (car dans ce cas il faut ajouter T et pas Q) . Comment t'en sort tu?

idem sur une seule branche qui en collecte d'autre, quand un bloc est une jonction, il faut utiliser son total.... je testerai tout ça... le temps le temps, le temps et rien d'au autre...

[didier]

Coucou

 

C'est typiquement ce que j’expliquais plus haut

Chaque métier a ses particularités, si on en est pas on connaît souvent quelques grandes lignes mais on fait des impasses sur les détails

 

Il y a très longtemps j'avais ouvert un forum sur CadXP : programmer pour le fun

Le but était de faire travailler les gens sur des choses connues de tous et on arrivait à échanger car justement on a tous les mêmes bases

Dès qu'on parle "métier" on bute sur des inconnues, on peut faire le squelette d'un programme mais rarement dans le détail.

 

Je vais regarder le code d'Olivier pour le décortiquer même s'il me semble avoir saisi la logique, c'est toujours bon de voir comment font les autres.

 

Au fait : est-ce que je peux utiliser ton dessin et ton souci pour créer des exemples sur mon site da-code ?

 

Amicalement

[x_all]

le diable se cache dans les détails...

 

bien sur que je ne m'attend pas à ce qu'un non "spécialiste" soit sensible aux subtilités du calcul, mais dans l'approche générale, je trouve intéressant de regarder comment vous appréhendez le problème. j'ai trouvé super efficace ta façon de sélectionner les blocs, et je garde l'idée sous le coude, même si je ne m'en suis pas servi car tout était presque bouclé. Pour le code d'olivier, je ne sais pas s'il est spécialiste, mais j'ai l'impression qu'il a bien compris le problème. Avec une plus valu de pro du lisp qui me laisse sans voix.

 

Il y aura peut être des réglages, mais ce squelette très modulable répond à pas mal de problématique. On passe son temps en réseau à cumuler des valeurs sur une ligne.Débits EP, Ventil, calcul de résistivité en élec, relation de pente et fe en gravitaire...

Et puis sans faire du bim, les blocs sont adaptables et il suffit de rajouter des attributs pour renseigner des types de bouche, de canalisation (N ver N+1 est unique) d'alti de pente en tenant compte de la distance entre deux noeds. Bref hyper satisfait de la tournure que prennent les choses.

 

Pour ton site bien sur que tu fais comme tu veux, même si là encore on ne joue pas dans le même cours, je pille régulièrement les lumières et bonnes ondes de CadXp pour mes carnets de notes numérique.

[Olivier Eckmann]

Bonjour,

 

Pour le multi branche, quand je rencontre un bloc, si le total est à 0, c'est que son débit n'a jamais encore été utilisé, donc j'ajoute son débit au total en cours sur la poly, par contre si le T n'est pas nul (c'est un bloc de jonction), c'est que le débit a déjà été ajouté par une autre branche, donc j'ajoute le T du bloc au total en cours sur la branche pour le mettre à jour.

C'est pour ça que comme je le disais précédemment, il faut que tous les T soit = 0 au début et que tu traites branche par branche dans le sens "descendant/cumulatif" des tes jonctions.

En relisant rapidement, il me semble la variable dDistMin ne sert à rien, mais ça ne devrait pas géner le fonctionnement. Par contre il n'y a pas de contrôle sur le fait qu'on puisse sélectionner des blocs autres que ceux à cumuler au début. On pourrait ajouter un test pour être sûr que chaque bloc ajouté à la liste initiale dispose bien des attributs T et Q.

Olivier

[x_all]

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.

[x_all]

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....

Modifié le 27 mai 2018 par didier
Édité pour correction des sauts de ligne