Importare file dati in Excel

E’ indubbio che Excel come tutti i fogli di calcolo sia ormai uno strumento indispensabile nell’analisi dei dati, e sicuramente tutti vi siete trovati ad affrontare il triste problema della “virgola”.

Infatti nelle impostazioni Italiane (ma forse anche straniere), i formati decimali sono separati da “,” e non da “.” .

Questo può creare dei problemi quando si devono importare file numerici realizzati da altri software o scaricati da data-logger, proprio come era successo a me anni fa.

Il problema di per se è facilmente risolvibile quando il file da importare contiene solo numeri decimali con separazione basata su “.”, in questi casi si apre il file con un qualsiasi editor e si esegue la sostituzione automatica di “.” con “,” in tal modo il gioco è fatto e si importa direttamente in Excel un file leggibile secondo il formato che esso si attende.

Tuttavia esistono casi in cui l’operazione precedente non è possibile, in particolare quando il file da importare è mostruosamente grande, ed in tal caso occore un editor di testi serio, o quando il file contiene dati promiscui, come ad esempio il file che dovevo importare io:

000000    25/10/2004    17.07.35    21.487    1.612    26.90    27.17
000001    25/10/2004    17.17.38    21.223    1.596    26.05    27.04
000002    25/10/2004    17.27.35    20.820    1.574    25.08    25.89
000003    25/10/2004    17.37.35    19.464    1.515    23.74    24.90
000004    25/10/2004    17.47.35    16.722    1.426    22.43    23.74
000005    25/10/2004    17.57.35    11.868    1.233    21.33    22.81
000006    25/10/2004    18.07.35    6.576    0.809    20.38    21.99
000007    25/10/2004    18.17.35    2.836    0.382    19.77    21.67
000008    25/10/2004    18.27.35    0.746    0.110    19.30    21.56
000009    25/10/2004    18.37.36    0.090    0.013    19.26    21.62
000010    25/10/2004    18.47.36    0.010    0.001    18.95    21.56
000011    25/10/2004    18.57.36    0.003    0.001    18.92    21.63
000012    25/10/2004    19.07.36    0.003    0.001    19.25    21.62
000013    25/10/2004    19.17.36    0.002    0.001    19.11    21.45

Nel mio caso oltre ad essere un file piuttosto grosso,  (mesi di acquisizione dati), mi serviva modificare i separatori decimali solo dalla quarta colonna in poi, per cui il metodo pocanzi menzionato non era applicabile.

Per risolvere il problema sono bastate poche righe di codice C, dove imponevo di mutare i “.” in “,” dal secondo punto letto in poi per ogni riga.

Quindi ho prodotto il seguente codice, dove con DOT_LIMIT pari a 2 richiedo la modifica a partire dal terzo “.” letto, e DOT_UP_LIMIT pari a 6 per azzerare il contatore a fine linea.

Riposto il codice, per quanto banale  spero possa essere utile a qualcuno.

#define DOT_LOW_LIMIT 2
#define DOT_UP_LIMIT 6
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  FILE *fpin;
  FILE *fpout;

  int dot_count;
  char carattere;

  if (argc !=3 )
  {
           fprintf(stderr,"Uso: %s <file_in> <file_out>\n",argv[0]);
           exit(0);
  }

  fpin = fopen(argv[1],"r");
  fpout = fopen(argv[2],"w");

  dot_count = 0;

  while(fscanf(fpin,"%c",&carattere) != EOF ){
           if (carattere == EOF) break;
           if (carattere == '.'){
                         dot_count++;
                         if(dot_count > DOT_LOW_LIMIT){
                                     fprintf(fpout,"%c",',');
                                     fprintf(stdout,"%c",',');
                         }
                         else{
                              fprintf(fpout,"%c",carattere);
                              fprintf(stdout,"%c",carattere);
                         }
                         if(dot_count == DOT_UP_LIMIT) dot_count = 0;
           }
           else{
                fprintf(fpout,"%c",carattere);
                fprintf(stdout,"%c",carattere);
           }
  }

  fclose(fpin);
  fclose(fpout);

  return 0;
}

Ottenendo questo risultato:

 

000000    25/10/2004    17.07.35    21,487    1,612    26,90    27,17
000001    25/10/2004    17.17.38    21,223    1,596    26,05    27,04
000002    25/10/2004    17.27.35    20,820    1,574    25,08    25,89
000003    25/10/2004    17.37.35    19,464    1,515    23,74    24,90
000004    25/10/2004    17.47.35    16,722    1,426    22,43    23,74
000005    25/10/2004    17.57.35    11,868    1,233    21,33    22,81
000006    25/10/2004    18.07.35    6,576    0,809    20,38    21,99
000007    25/10/2004    18.17.35    2,836    0,382    19,77    21,67
000008    25/10/2004    18.27.35    0,746    0,110    19,30    21,56
000009    25/10/2004    18.37.36    0,090    0,013    19,26    21,62
000010    25/10/2004    18.47.36    0,010    0,001    18,95    21,56
000011    25/10/2004    18.57.36    0,003    0,001    18,92    21,63
000012    25/10/2004    19.07.36    0,003    0,001    19,25    21,62
000013    25/10/2004    19.17.36    0,002    0,001    19,11    21,45

CAD per LINUX? Si grazie (seconda parte)

Un semplice aggiornamento del precedente post.

E’ disponibile Draft sight della Dassault System (il produttore del famosto SolidWorks), è gratuito,legge i .dwg e dopo quasi un anno che lo provo devo dire che è veramente ben fatto.

A mio parere il miglior CAD gatuito attualmente disponibile per Linux, e sicuramente perfetto per l’uso professionale.

L’ho usato per creare schemi oleodinamici, importando blocchi, incollando immagini, aprendo file preesistenti in .dwg e nonostante sia una beta mai un crash.

Cosa aspettate? Provatelo sulla vostra Linux box.

http://www.3ds.com/it/products/draftsight/download-draftsight/

P.S.: Se non avete Linux, potete provarlo sul vostro windows o Mac OSX

 

Un comodo TEMPLATE per analisi FEM tramite CALCULIX

Calculix è uno strumento veramente interessante e valido, ccx (il solutore) e cgx (il pre e post processore) sono validi quanto, per certi versi oscuri.

In questi casi basta un piccolo template per migliorare l’usabilità.

Supponiamo di voler analizzare un pezzo meccanico di cui abbiamo già fatto la mesh.

In tal caso il nostro file template.inp sarà il seguente:

** con "**" si indicano delle linee di commento

** Indichiamo il file che contine la mesh di tutto il modello
*INCLUDE, INPUT = mesh.all

** Indichiamo il file contenente le cordinate dei nodi vincolo:
*INCLUDE, INPUT = vincoli.nam

** Specifichiamo nome del matetiale e caratteristiche meccaniche con le adeguate grandezze dimensionali
*MATERIAL, Name = acciaio_C40
*ELASTIC
22000, 0.3

** Indichiamo il set di nodi a cui associare il materiale, "Eall" è un set definito nel file mesh.all
*SOLID SECTION, Elset=Eall, Material = acciaio_C40

** Con il comando STEP avviamo la parte relatica all'analisi, in questo caso statica
*STEP
*STATIC

** Definiamo le condizioni al contorno, i nodi in vincoli.nam sono bloccati nelle direzioni 1,2,3 (x,y,z)
*BOUNDARY
Nvincoli, 1,2,3

** Definiamo il carico distribuito assegnato che è presente sul dile carico.dlo
*DLOAD
*INCLUDE, INPUT = carico.dlo

** Indichiamo il tipo di risultati che vogliamo visualizzare
*NODE FILE
U

*EL FILE
S, E

*END STEP

Arduino, si comincia

Questa sera mi sono finalmente convinto a comprare uno starter Kit per Arduino UNO.

Prossimamente su questi schermi

Fortran parte 3: Fortran Vs. C/C++ o compilatore Vs. compilatore?

Basta fare una ricerca dove si vogliono recuperare informazioni circa le performances offerte dal Fortran95 contro C/C++ e si trovano centianai di benchmark a favore dell’uno e dell’altro linguaggio.

Se poi si va su gruppi di discussione si assiste a vere e proprie guerre di religione per partito preso e che quasi sempre si concludono con insulti.

Non è mia intenzione schierarmi dall’una o dall’altra parte, credo semplicemente che i software, come qualsiasi altra cosa, sono dei prodotti che devono essere ingegnerizzati.

Quindi quando c’è da metter giù due righe di codice si può partire alla “garibaldina”, ma quando le cose sono serie ed impegnative occorre spendere del tempo per svolgere delle analisi e successivamente impostare l’architettura del software e la scelta degli strumenti da usare.

Tra gli strumenti c’è sicuramente il linguaggio di programmazione, difficilmente un solo linguaggio è adatto a coprire tutti gli scopi.

Attenzione, con un linguaggio come ad esempio il C o il C++ si può fare praticamente tutto, non a caso sono “general purpose“, e devo essere sincero, sono un grande ammiratore di questi linguaggi e delle loro potenzialità.

Ma in un ambiente di produzione il fattore tempo è fondamentale, il ricorso a strumenti che facilitano certe parti del progetto è, a mio parere, obbligatorio.

Il Fortran non si pone come un linguaggio per risolvere qualsiasi problema, il Fortran si pone come un linguaggio per la soluzione di problemi numerici.

In tale ottica offre una serie di strumenti che altri linguaggi non hanno, per capirci dovendo spiegare quale è il linguaggio più somigliante al fortran, io dire Matlab.

La sostanziale differenza è che Fortran necessita di compilatori, Matlab mi pare sia in pseudocodice.

Ma torniamo alla questione Fortran Vs. C/C++, voglio solo fare degli esempi per dare una idea di quello che mi piace del Fortran ma anche del C/C++.

Si prenda in considerazione l’esempio seguente, una matrice B contiene dei valori numerici, ed una seconda matrice A è nulla.

Si vuole che A assuma gli stessi elementi di B quando questi sono pari.

Il problema proposto è solo uno spunto per mostrare le capacità del linguaggio.

In C si può scrivere il seguente programma:

#define X 15000
#define Y 15000
#define ESECUZIONE 5

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

int main(void)
{
  int i,j,k;
  int **a;
  int **b;

  for(k=0;k<ESECUZIONE;k++)
  {
    a = malloc(sizeof(int)*X);
    b = malloc(sizeof(int)*X);

    for(i=0;i<Y;i++)
    {
      a[i] = malloc(sizeof(int)*Y);
      b[i] = malloc(sizeof(int)*Y);

      for(j=0;j<Y;j++)
      {
        b[i][j] = j+1;
      }
    }

    for(i=0;i<X;i++)
    {
      for(j=0;j<Y;j++)
      {
        if((b[i][j]%2)==0)
        {
          a[i][j] = b[i][j];
        }
      }
    }
    printf("%d\n",a[10-1][10-1]);

    for(i=0;i<X;i++)
    {
      free(a[i]);
      free(b[i]);
    }
    free(a);
    free(b);
    return 0;
}

return 0;
}

Come si potrebbe scrivere lo stesso programma in Fortran95?
Ecco la risposta:

program esempio
implicit none

integer, parameter :: X = 15000
integer, parameter :: Y = 15000
integer, parameter :: ESECUZIONE = 5

integer :: i,j,k

integer, allocatable :: A(:,:), B(:,:)

do k=1,ESECUZIONE
 allocate(A(X,Y))
 allocate(B(X,Y))

 A = 0

 do j=1,Y
     B(:,j) = (/(i,i=1,X)/)
 enddo

 where(mod(B,2)==0) A=B

 write(*,*) B(10,10)

 deallocate (A)
 deallocate (B)

enddo
end program esempio

o più sinteticamente:

program esempio_2
implicit none

integer, parameter :: X = 15000
integer, parameter :: Y = 15000
integer, parameter :: ESECUZIONE = 5

integer :: i,j,k

integer, allocatable :: A(:,:), B(:,:)

do k=1,ESECUZIONE
	allocate(A(X,Y))
	allocate(B(X,Y))

	A = 0

	forall(j=1:Y)
		B(:,j)=j
	end forall

	where(mod(B,2)==0) A=B

	write(*,*) B(10,10)

        deallocate (A)
	deallocate (B)
enddo
end program esempio_2

La cosa evidente, a prescindere da fatto che abbiate capito qualcosa nel codice Fortran , è che in Fortran le linee di codice richieste sono effettivamente poche, e vi assicuro che se si conosce il linguaggio sono anche estremamente leggibili.

Vi ho mostrato due versioni in Fortran95, la differenza tra i due sta nel fatto che nel primo codice uso un ciclo DO…ENDDO per riempire la matrice B lungo le colonne, ciò è necessario per velocizzare gli accessi in memoria visto che il Fortran organizza i dati in memoria seguendo l’ordine delle collone, a differenza del C/C++ che seguno le righe.

Nel secondo codice il ciclo DO…ENDDO precedende è sostituito dal un ciclo FORALL…END FORALL, tale ciclo è molto particolare, e dovrebbe dare il meglio di se su architetture multiprocessore.

Infatti FORALL implementa il calcolo parallelo nativamente e direttamente dal compilatore, cosa non da poco, purtroppo io dispongo di un sistema non proprio performante e per di più monoprocessore infatti eccovi la scheda del mio sistema:

Adesso passiamo alla copilazione ed al “benchmark” dei codici.

Per la precisione userò una versione per usi non commerciali del compilatore Fortran di Intel e l’immancabile gcc per il codice in C.

Compilo i primi due codici ed ottengo:

Quale è la conclusione?

La velocità dipende:

- dal tempo impiegato a scrivere tutte le righe di codice

- da come il programmatore implementa il codice

- dal tempo impiegato a debuggare

- dalle ottimizzazioni realizzate dal compilatore

Circa l’ultimo punto ho una domanda, come mai gfortran che poi è gcc impiega più tempo rispetto alla versione in C, mentre il compilatoreo ifort impiega praticamente lo stesso tempo di gcc?

Ovviamente questo test non è un test valido per qualificare le prestazioni dei compilatori.

Se qualcuno prova ed eseguire i test su una macchina dual core mi farebbe piacere avere i risultati.

In tal caso il codice fortran da usare è il secondo dove è presente l’istruzione FORALL.

Appena recupero i sorgenti della mia tesi, vedo di eseguire un test sui diversi compilatori, a suo tempo impiegava 60 ore, compilatore Compaq Visual Fortran e un bel PC da 3200 Mhz.

Fortran parte 2: Passare i parametri dalla riga di comando

Mi è sempre piacuta la possibiltà di passare dei parametri ad un programma nel momento in cui lo si lancia dalla riga di comando.

Ciò è estremamente semplice in C/C++, basta infatti:

#include<stdio.h>
int main(int argc, char* argv[])
{
    int i;
    printf("Passati %d parametri\n",argc);
    printf("I parametri sono:\n");
    for(i=1;i<argc;i++) { printf("%s\t",argv[i]);}
    printf("\n");
    return 0;
}

Sono rimasto sorpreso e stupito che lo si possa fare con il fortran9x, occore richiamare due funzioni native ed ecco:

program parametri
implicit none
integer :: argc, i
character(len=256) :: argv
argc = command_argument_count()
argnum = command_argument_count()
write(*,*)  "Numero argomenti: ",argc
do i = 1, argc
 call get_command_argument(i,argv)
 write(*,*) argv
end do
end program parametri

Fortran Parte I: Gli array in Fortran95

Molti ridono quando sentono parlare del Fortran, ma di fatto chi programma in tale linguaggio non è mai un informatico di professione.

In genere chi usa tale linguaggio è una persona che necessita di scrivere del software che si deve interfacciare direttamente a persone o sistemi, ma per la precisione, scrive  software per il calcolo numerio.

Tutti i linguaggi sono pensati per eseguire calcoli, ma nessuno permette di ottenere le prestazioni e la semplicità di base che si può ottenere con il Fortran95.

In questa breve nota mostrerò l’aspetto che più apprezzo di questo linguaggio, e che alla fine è quello che mi impedisce anche di passare al C o similari, parliamo di ARRAY!

ARRAY in FORTRAN

Un Array è un insieme di dati omogenei, e non differesiche in nulla da quelli che sono gli array in altri linguaggi.

Possiamo quindi avere:

• Array di numeri interi
• Array di numeri reali
• Array di numeri complessi
• Array di caratteri
• Array di tipi personali, cioè di tipi creati per uno scopo preciso

Ancora una volta gli array possono essere statici o dinamici, e vedremo più avanti cosa vuol dire.

Per un ingegnere, un fisico, un matematico, un chimico, una persona che vuol fare dei calcoli, l’array non è altro che una MATRICE.

Possiamo avere array monodimensionali, quindi avremo un VETTORE, o array multimensionali quindi MATRICI.

In molte materie scientifiche si realizza un modello matematico basato su matrici ed il calcolo matriciale per semplificare il problema.

Gli esempi sono innumerevoli:

• L’analisi del moto dei corpi celesti
• La scienza delle costruzioni
• L’analisi agli elementi finiti
• La fluido dinamica numerica
• L’aerodinamica applicata
• ecc.

Per cui possedere un linguaggio che gestisca in modo diretto le matrici non è cosa da poco.

Passiamo agli esempi

Dichiarazione degli ARRAY

integer :: matrice(10,10)
integer, dimension(10,10) :: matrice

con le due dichiarazioni precedenti si crea una matrice di interi di rango 10×10

analogamente si può creare un vettore di numeri reali o complessi:

double precision :: vettore(10)

double precision, dimension(10) :: vettore

Le dichiarazioni precedenti sono usate quando si conosce a priori la dimensione dell’array da usare, in molti casi si può avere a che fare con array dalle dimensioni sconosciute, in tal caso occore usare gli array dinamici ed allocare di volta in volta lo spazio i memori necessario.

La dichiarazione è simile alla precedende, ma al posto della dimensione si inserisce il simbolo “:”.

integer, allocatable :: matrice(:,:)

integer, allocatable, dimension(:) :: vettore

ALLOCATE(matrice(10,10))

ALLOCATE(vettore(10))

Per liberare la memori quando le matrici non sono più necessarie basta:

DEALLOCATE(matrice)

DEALLOCATE(vettore)

ASSEGNAZIONI DI VALORI AGLI ARRAY

Gli array possono essere usati come semplici variabi sia con la metodologia di accesso in lettura e scrittura basata su indici, quindi:

WRITE(*,*) A(i,j) -> stampa l'elemento di coordinate (i,j)

A(i,j) = 5 -> assegnail valore 5 all'elemento di coordinate (i,j)

Ma fin qui tutto è in linea con le possibilità offerte da C/C++, vediamo quindi le peculiarità circa l’uso degli array.

INTEGER :: A(10,20;30)  ! creo un array di interi 10x20x30

A = 1 ! tutti gli elementi dell'array sono pari ad 1

A(1,:,:) = 2 ! tutti gli elementi che hanno il primo indicie pari a 1 assumono valore 2, quindi A(1,1,1) = 2, A(1,1,3) = 2, ..., A(1,20,30) = 2

A(1,1,:) = 3 ! tutti gli elementi di coordinate inizilia (1,1) hanno valore = 3, quindi A(1,1,1)=3, A(1,1,2)=3, ...; A(1,1,30) = 3

C = A+B !somma indice ad indice gli elementi di un array ovviamente si può avere anche la sottrazione
 

C=A*B ! moltiplica indice ad indice

Tali modi di accesso possono essere usati per ridurre le righe di codice, semplificare la lettura e permette al compilatore di implementare l’ottimizzazione migliore di accesso, specialmente quando si ha a che fare con migliaia o milioni di elementi.

FUNZIONI NATIVE PER GLI ARRAY

Il linguaggio offre delle funzioni native per particolari operazioni su array quali:

DOT_PRODUCT(A, B) ! prodotto scalare di A e della B

MAXVAL(A)  !  restituisce il valore maggiore dell'array A

MINVAL(A)  !restituisce  il valore minore di A

MAXLOC(A)  !  restituisce le coordinate le valore maggiore di A

MINLOC(A)  ! restituisce le coordinate del valore minore di A

PRODUCT(A)  ! prodotto degli elementi di A

SUM(A) ! somma gli elementi di A

TRANSPOSE(A) ! crea la matrice trasposta

e molte altre ancora per fare lo scorrimento degli elementi, la scelta di elementi da leggere o scrive con l’applicazioni di filtri (chiamati maschera) ecc.

Il mio intento non è quello di scrivere una guida, se il linguaggio vi interessa potete chiedere qui o consultare i diversi manuali che si trovano in rete.

vi lascio con un piccolo esempio:

Qui il risultato:

Ci sarebbe ancora molto da scrivere, ma sarà per la prossima volta.

Infatti non abbiamo parlato di compilatori, lo faremo prossimamente, per ora vi lascio qualche link per curiosare e provare se queste poche note vi hanno incuriosito.

http://hpff.rice.edu/index.htm

http://www.dmi.units.it/~chiarutt/didattica/parallela/fortran/index.html

http://www.nsc.liu.se/~boein/f77to90/f77to90.html#index

HST Parte 2: Calcolo di una trasmissione idrostatica

Il calcolo di una trasmissione idrostatica è abbastanza semplice, ma piuttosto lungo  e noiso a causa delle iterazioni che possono essere richieste.

Per velocizzare i tempi di calcolo e verifica ho preparato un foglio di calcolo tramite OpenOffice.

Sto ancora lavorandoci su per inserire altre opzioni, quali una differenziazione dei calcoli nel caso si abbia a che fare con circuiti aperti o chiusi.

Così come sto inserendo opportune maschere di richiesta data in funzione del tipo di azionamento che sia richiesto, ad esempio:

- trasmissione di veicolo gommato

- trasmissione di veicolo cingolato

- azionamento di un alternatore

- azionamento di un ventilatore/elica

- azionamento di cilindri

Mi ci vorrà del tempo viste le ristrette disponibilità del tempo tempo libero.

Vi do tuttavia una piccola anteprima.

Prendendo spunto da diverso materiale didattico disponibile su  internet, e di cui vi indico i link:

- https://www.ing.unimore.it/campusone/visualizzazioneingegneria/StreamFile.asp?File=../MaterialeDidattico/Matdidattico5329/Trasmissione_idrostatica_base.pdf

- http://www.werthercampaldi.it/tesine/Tesina_Mercati.pdf

- http://www.diem.ing.unibo.it/personale/naldi/O&P_07.50_2010.03.11_BR_Trasmissioni_R3.pdf

ho messo su un foglio di calcolo di cui vi mostro alcune parti.

Foglio di calcolo

e qui i risultati numerici ed il grafico:

Risultati

Grafico

Sto cercando di correggere alcuni piccoli errori nel foglio di calcolo e di completare le funzionalità.

Se siete interessati al foglio di calcolo lasciate pure un commento.

HST parte 1: Verifica di un colletore in pressione

Spesso nell’impiantistica oleodinamica si utilizzano dei collettori con lo scopo di raccogliere o smistare delle portate di fluido da una linea ad altre o nel caso della raccolta di convogliare più linee sulla linea di ritorno.

Spesso tali linee sono linee in pressione per cui il colletore diventa un elemento le cui parti devo essere calcolate per garantire la corretta tenuta strutturale oltre che le basse perdite di carico e l’economicità del sistema.

Bene, a questo punto ciò che ci occorre per iniziare la nostra attività progettuale è un foglio di carta, una matita ed una calcolatrice per realizzare il primo schizzo.

Fatto lo schizzo occore creare un modello 3D, o con un qualsiasi software commerciarciale oppure con Salome

Realizzato il modello occorre esportare il tutto in formato step (.stp).

A seguire le immagini del modello creato con SALOME:

Modello del collettore

Una visualizzazione più chiara può essere la seguente:

Bene, a questo punto occorre esportare il modello in formato .stp, ciò si rende necessario perchè volendo fare una analisi agli elementi finiti ci occore un formato di scambio tra il modellatore ed il “meshatore”, cioè il software che renderà discreto il modello continuo del solido.

Come meshatore mi trovo benissimo con netgen e quello che segue è il risultato del lavoro di mesh:

qui un dettaglio:

Adesso la mesh va esportata nel formato abaqus, e quindi possiamo passare ad usare i tool di pre-processing, processing e post-processing di Calculux, ciò del software per anlisi agli elementi finiti.

Usando il pre-processing di CalculiX (cgx) possiamo selezionare le superfici che saranno interessate ad una pressione di 400 bar:

Selezione superfici mesh su cui applicare 400 bar

Questo il file di input usato per calculix:

File input per CalculiX

Bene a questo punto basterà usare il modulo di post-processing di CalculiX per vedere nell’ordine le tensioni di Von Mises su tutto il modello e su una sezione in particolare:

Tensioni di Von Mises

Tensioni di Von Mises su una sezione particolare

bene per oggi è tutto.

Spero sia utile e stimolante per le vostre attività.

HST Hydraulics Software & Tools, Software e tool vari per l’oleodinamica

Non ho tutto il tempo necessario da dedicare alla cura adeguata di queste poche scarne pagine che segno di tanto in tanto sul blog.

Uso solo i ritagli di tempo che la vita privata e la vita lavorativa mi permettono, e ciò si scontra molto con l’idea iniziale che avevo di creare piccole ma dettagliate guide su software particolarmente interessanti per l’attività professionale e acor di piu’ per il fatto di essere open-source e quindi praticamente primi di costi di acquisto.

Ho quindi rivisto i miei obiettivi in funzione del tempo ed ho deciso di cambire il taglio delle note che andrò a redigere.

Con la sigla HST indicherò una serie di brevi “case history” dove mostrerò l’uso che un progettista o una azienda possono fare dei software open source per migliorare i propri prodotti ad un costo contenuto, la cosa penso possa essere molto interessante per tutti i colleghi che esercitano la professione in ambito oleodinamico.

Quindi HST sarà una breve e veloce carrellata di cosa si possa fare con i principali software disponibili su internet e a costo nullo o quasi se non si considerano le ore necessarie per l’apprendimendo.

Quindi se qualcuno ha bisogno di chiarimenti non esiti a scrivere sul blog, farò quello che posso nei tempi che ho

Ma alla fine cosa troverete in HST?

troverete esempi d’uso di software quali:

- Calculix

- Salomeca

- Scilab e Scicoslab

- Qcad

- DIA

- Open Office

- gcc e gfortran (compilatore C e Fortran)

- Netgen

- Elmer

- gmsh

e tanti altri che ora non ricordo ma che certamente mi verrano in mente.