Robitex's Blog

Ideas in the web

Archivi Categorie: Nolian

Verticalizzare nodi in Nolian


Scarica l’articolo nel formato PDF per la stampa

Nolian scripting series, episode 3

Verticalizzare! Quando?

Di solito non modello le fondazioni a platea direttamente in InMod perché preferisco costruire la mesh per conto mio direttamente in Nolian, mi è capitato quindi, di importare da un file binario, i dati di una platea di una struttura molto simile rispetto in quella in lavorazione (in realtà la stessa struttura modificata in varie versioni, sigh!).

L’operazione è riuscita perfettamente ma alcuni nodi al piede dei pilastri, risultavano collegati alla mesh con un rigel non perfettamente verticale. Nolian ha aggiustato le posizioni dei nodi che capitavano vicini a nodi esistenti, di sua spontanea volontà.

Per rendere i rigel di nuovo verticali, occorreva risistemare le coordinate dei nodi corrispondenti della mesh, ma ecco che una manciata di righe di codice Lua può abbreviarci il lavoro.

La nuova funzione axy()

Ho pensato ad una funzione chiamata axy(), ovvero assegna x ed y, con il seguente funzionamento: seleziono il nodo al piede del pilastro e poi quello sulla platea, dopo di che la funzione esce fatta la modifica.

Ecco il codice da gestire secondo le indicazioni contenute nel primo episodio (ricordo che dopo la configurazione sarà disponibile in console il comando axy() ):

function axy(x,y)
     if not x or not y then
          print("Sel node con la posizione planimetrica desiderata...")
          _sel.doselect( true )
          local nodobase = _sel.nodes()
          _sel.clear()
          if #nodobase > 1 then
             print ("Selezionati più nodi, riprova.")
             return
          else
	     local p = _n.get(nodobase[1])
	     x = p.x
             y = p.y
          end
     end
     
     print("Selezionare nodo da cambiare con x=" .. x .." e y="..y .." ...")
   
     _sel.doselect( true )
     local nodo = _sel.nodes()
     _sel.clear()
     
     if #nodo > 1 then
         print ("Selezionati più nodi, riprova.")
         return
     end
     
     local pointAux = {}
     pointAux.x = x
     pointAux.y = y
     nodeIndex = nodo[1]
     
     _n.set(nodeIndex, pointAux)
end

Commento al codice

La prima parte del codice della funzione non fa altro che decidere se le coordinate planimetriche sono o no state specificate dall’utente. Se no, aspetta che si selezioni un nodo prelevandone poi i valori utili delle coordinate con la funzione di libreria _n.get() che, come recita il manuale stringatissimo di Softing (più stringato di così…), restituisce il punto relativo all’indice del nodo specificato. Punto che non è altro che una tabella Lua con chiavi x, y, e z.
Riassumendo, la funzione _sel.nodes() restituisce una tabella con gli indici dei nodi selezionati, che in realtà in questo caso sono solo uno, appunto di posizione 1. L’indice dell’array viene passato alla _n.get() per il prelievo dei valori.

La seconda parte invece, effettua l’assegnazione ad un secondo nodo selezionato: si crea infatti un punto detto pointAux con le nuove coordinate e lo si passa alla funzione _n.set() assieme all’indice del nodo selezionato. Più difficile a dirsi che a farsi!

Grazie ed alla prossima!

Annunci

Assegnare le coordinate x y o z ai nodi in Nolian


Nolian scripting series, episode 2

Prima che finisca questo video che spesso mi accompagna nel pensare a mio padre, e prima che venga Natale, vi posto una versione evoluta del codice della puntata precedente alias episode 1.

Un paio di modifiche…

Per prima cosa ho ampliato la funzione al caso in cui l’utente non specifichi la coordinata da applicare, desumendola da un nodo campione selezionato dall’utente stesso.

Possiamo quindi lanciare il comando az(), cliccare su un nodo che si trova già alla quota desiderata (coordinata z), e selezionare i nodi destinazione. Oppure possiamo specificare il valore di zeta, sempre tra parentesi tonde, e applicare la modifica selezionando direttamente i nodi sul modello.

La seconda modifica è a livello implementativo per la generalizzazione della funzionalità: ho scritto una metafunzione che ho chiamato assegnaCoordNodi che accetta come primo argomento una stringa relativa al nome dell’asse coordinato “x”, “y” o “z”. In questo modo è immediato scrivere le funzioni utente ax(), ay(), ed az(), tutte con la stessa sintassi e con lo stesso comportamento.

Adesso potete assegnare ad un qualsiasi gruppo di nodi del modello in Nolian una coordinata x, y o z. Ecco il codice:

-- libreria delle funzioni personali in Nolian
--
-- Copyright (c) 2010 Roberto Giacomelli
-- email: giaconet dot mailbox at gmail dot com
--
-- 2010/12/15
-- released under the term of https://robitex.wordpress.com/legalese

-- meta function
-- Assegna ai nodi selezionati una stessa coordinata
function assegnaCoordNodi( coord , val )
   if not coord then
       print ("Errore di libreria: asse coordinato non specificato.")
       return
   elseif not(coord ~= "x" or  coord ~= "y" or coord ~= "z") then
       print ("Errore di libreria: asse "..coord .." non riconosciuto.")
       print("Deve essere o 'x' o 'y' o 'z'")
       return
   end
   
   if not val then
      print("Selezionare il nodo con la "..coord.." desiderata...")
      _sel.doselect( true )
      local nodobase = _sel.nodes()
      _sel.clear()
      if #nodobase > 1 then
         print ("Selezionati più nodi, riprova.")
         return
      else
         val = _n.get(nodobase[1])[coord]
      end
   end
   
   print("Selezionare nodi da cambiare con " .. coord .."="..val .." ...")
   
   _sel.doselect( true )
   nodi = _sel.nodes()
   _sel.clear()
   
   local pointAux = {}
   for i, nodeIndex in ipairs( nodi ) do
       pointAux[coord] = val
       _n.set(nodeIndex, pointAux)
   end
   
   print( #nodi .." nodi modificati con coord. " .. coord .. "=" ..val)
end


function ax(x)
   assegnaCoordNodi("x", x)
end

function ay(y)
   assegnaCoordNodi("y", y)
end

function az(z)
   assegnaCoordNodi("z", z)
end

Un uso con variabili

Per come è costruita Lua, nella console (nella finestra di comando dello scripting interno di Nolian che appare con CTRL + T), abbiamo a disposizione un ambiente interattivo completo. Ciò significa che possiamo settare variabili ed utilizzare espressioni numeriche come argomento delle funzioni ax, ay, az. Per esempio questa sessione in console è valida:

> z1 = 145.5
> z2 = 258.5
> az ( (z1+z2)/2 )
> az (2/3*(z1+z2))

Le variabili rimangono disponibili fino all’uscita da Nolian. Possiamo perfino pre-caricare valori costanti inserendoli nel file mylib.lua, file dove abbiamo deciso di custodire i nostri script. Sempre più fantastico vero?

So,
Dedicated to my father.

Assegnare coordinate ai nodi in Nolian


Nolian scripting series, episode 1

Scarica l’articolo in PDF per la stampa

Benvenuti,
da qualche versione a questa parte Nolian permette l’esecuzione di comandi personalizzati. Questa funzionalità è chiamata dalla Softing scripting interno.
Questo post è il primo di una spero lunga e proficua serie dedicata a potenziare le nostre capacità di modellazione agli elementi finiti in Nolian. Lasciate un commento per qualsiasi cosa.

Il primo problema che affrontiamo è questo: assegnare una stessa coordinata ad un gruppo di nodi. Ci dilungheremo solo per questa volta sulle questioni pratiche per poi risolvere brillantemente ciò che con le funzioni standard risulta noioso.

Questioni implementative

Con il roboante titolo di questo paragrafo, intendo spiegare come far eseguire un nostro comando con riferimento alla versione EWS32 di Nolian.
La prima e piacevole cosa da sapere è che il motore di scripting interno funziona con Lua. La bellissima notizia è motivata dal fatto che Lua è un linguaggio elegante e potente, e con esso è possibile non solo gestire ogni aspetto del nostro modello ma anche ideare comandi con una sintassi flessibile, in puro stile hacker.

The Nolian scripting Console

The Nolian scripting Console

1 – Avviamo dunque una sessione di Nolian e premiamo la combinazione di tasti CTRL + T per avviare la console di scripting.
La console offre una riga di comando ed un pannello testuale per visualizzare l’output (vedi screenshot). D’ora in poi quando diremo console ci riferiremo ad essa.

2 – Operazione matematica
Al prompt della console che non è altro che un ambiente di comando Lua, per prima cosa eseguiamo un calcolo digitando:

> 2*math.pi*100

Il risultato è prontamente stampato nella finestra di output.

3 – Creazione di una prima funzione
Metti che non ci ricordiamo l’area di una barra d’acciaio, allora al prompt digitiamo riga dopo riga il seguente codice:

> function area( d )
>> return math.pi * d^2 / 4
>> end
> area (1.4)
> area(1.2)
> area(1.6)

Da questo momento fino a che non viene definitivamente chiusa la sessione di Nolian, la funzione area() sarà a disposizione.

Il nostro primo vero script

Creiamo una nuova directory nella cartella d’installazione di Nolian chiamata lua, dove sistemeremo i file di testo dei nostri script, quindi aprite un editor (vi consiglio l’ottimo e gratuito SciTE), scrivete il codice print(“Ciao, questo è il mio primo script!”) e salvate il file con il nome primo.lua nella directory appena creata.
Eseguite lo script dando in console il comando dofile(“lua/primo.lua”).

Caricando in questo modo un file, tutte le funzioni in esso contenute vengono compilate e caricate nell’ambiente di scripting interno. Useremo questa tecnica per scrivere un file di nome mylib.lua, nella solita directory lua, caricando il quale avremo a disposizione le nostre funzioni personalizzate.

Ai nodi un ordinata

La funzione per assegnare un dato valore per la coordinata z dei nodi selezionati, si chiamerà az (assegna zeta). La selezione di un gruppo di nodi si implementa con la funzione _sel.doselect() memorizzata nella tabella _sel.
Poi dovremo gestire i nodi selezionati tramite un array contenente gli indici degli stessi:

_sel.doselect( true )
nodi = _sel.nodes()
_sel.clear()

Per ogni nodo dovremo poi modificare la coordinata zeta con la funzione _n.set(nodeIndex, pointAux) che si aspetta come primo argomento l’indice del nodo e come secondo argomento un punto, ovvero una tabella (l’unica struttura dati messa a disposizione da Lua), contenente la chiave z settata al valore voluto.

Queste funzioni, che cominciano un po’ discutibilmente con il carattere di trattino basso, sono quelle che ci permettono di interagire con il modello attualmente caricato nella sessione di Nolian.
Ecco il codice completo della funzione:

-- libreria delle funzioni personali in Nolian
--
-- Copyright (c) 2010 Roberto Giacomelli
-- email: giaconet dot mailbox at gmail dot com
--
-- 2010/12/15
-- released under the term of https://robitex.wordpress.com/legalese

-- Assegna ai nodi selezionati una stessa coordinata zeta
function az( z )
   if not z then
      print"Coordinata non specificata!"
      return
   end

   _sel.doselect( true )
   nodi = _sel.nodes()
   _sel.clear()
   
   local pointAux = {}
   for i, nodeIndex in ipairs( nodi ) do
       pointAux.z = z
       _n.set(nodeIndex, pointAux)
   end
end

Il suo uso è semplice: carichiamo la funzione memorizzata nel file individuato precedentemente, con dofile(“lua/mylib.lua”) in console. Poi diamo il comando seguente ed eseguiamo la selezione. I nodi prenderanno la quota specificata.

> az( 1203 )

Conclusioni

Uno script Lua non è altro che un file di testo. Caricando nostre librerie, possiamo accedere a funzioni che abbreviano senza errori e senza fatica l’inserimento dei dati del modello in Nolian.

Bibliografia

Acquistate il PiL e aiuterete lo sviluppo di Lua!!! Pure utile è la guida in linea di Nolian alla sezione dedicata.
The End.

%d blogger hanno fatto clic su Mi Piace per questo: