Le zanzare tigre hanno infestato ogni luogo. Ci impediscono di dormire la notte, ci impediscono di stare in giardino o in terrazza di giorno; si avvicinano con quell’insopportabile ronzio, ci deprivano di qualche microlitro del nostro liquido organico rosso e fuggono, ritornando poi per il pasto successivo.

Fin’ora mi sono sempre limitato a farle fuori con la mia fedele racchetta elettrica, ma ora ho deciso di provare a sterminarle alla radice: girando per il web ho infatto trovato una trappola, l’ovitrappola, che dovrebbe aiutarmi nel mio intento.
L’ovitrappola non è altro che un contenitore nero contenente dell’acqua. Posto nel terreno è considerato dalle zanzare un ottimo luogo per depositare le loro uova, una trappola che ci permette di distruggere le nuove generazioni dell’insetto.
Collocando un’ovitrappola nel terreno, in un vaso o in giardino, si dovrebbe riuscire a catturare un bel po’ di larve di zanzara, e tenendo conto che l’area di azione di una zanzara tigre è inferiore ai 200 m, magari si potrebbe passare il resto dell’esate in pace.

E allora così ho fatto: ho preso un barattolo di vetro trasparente, l’ho riempito per metà d’acqua e l’ho sotterrato in un vaso. Tra qualche giorno sapremo se questo rimedio alle zanzare funziona.

Molte delle persone che si iscrivono a ingegneria lo fanno perché o sono interessate alla matematica, o alla materia di una particolare facoltà d’ingegneria. Le prime persone sono quelle più dubbiose, proprio perché non sanno se iscriversi a matematica, fisica o ingegneria. Effettivamente, il matematico, il fisico e l’ingegnere sono tre persone molto diverse che hanno in comune proprio la matematica, però, il matematico studia la matematica nella sua astrazione più totale, il fisico la utilizza applicata ai fenomeni naturali e l’ingegnere per risolvere i problemi. Un esempio molto banale potrebbe essere il fenomeno della caduta dei gravi: il matematico studia le equazioni, il fisico trova l’equazione che descrive un corpo in caduta libera, l’ingegnere applica quest’equazione ai problemi che si trova davanti.

Un altro motivo per cui molti scelgono ingegneria è perché è facile trovare lavoro. Infatti, proprio per la loro natura di «risolutori di problemi», gli ingegneri sono quelli più ricercati nelle aziende, dove, se si verifica un problema, non c’è bisogno di qualcuno che trovi un teorema per risolverlo ma di qualcuno che lo risolva materialmente; e l’ingegnere sfrutta gli strumenti offerti dalla matematica e dalla fisica per risolvere i problemi.

Veniamo ora alla domanda più frequente: Quanta matematica bisogna sapere per iscriversi a ingegneria?
Gli studenti più preoccupati sono generalmente quelli del liceo classico o linguistico, perché hanno una preparazione in matematica che è inferiore a quella dei cugini dello scientifico. È vero che il programma del quinto anno di liceo scientifico è molto vicino al programma dell’esame di Analisi I, ma è anche vero che è l’unico esame in cui sono avvantaggiati. Per laurearsi ad una triennale bisogna sostenere circa venticinque esami. Un esame su venticinque è il quattro percento della laurea. Il quattro percento è ingegneristicamente trascurabile .
Per questo motivo non c’è alcun bisogno di preoccuparsi, per seguire i primi corsi di ingegneria sono sufficienti le basilari nozioni di trigonometria e qualche formula geometrica, come le relazioni sui triangoli rettangoli, perimetro ed area della circonferenza, piano cartesiano, ecc…
Quali sono allora le reali competenze richieste per un ingegnere? Sicuramente un minimo di ingegno, intuitività e intelligenza, che possono essere utili nelle altre materie, ma sono fondamentali per far fruttare appieno i corsi di ingegneria. Ricordate che l’obiettivo dell’ingegnere dev’essere quello di risolvere i problemi, e i problemi non si risolvono imparando formule e dimostrazioni a memoria ma sapendoli applicare in maniera corretta.

Una volta deciso di voler fare ingegneria resta un problema: Che ingegneria scelgo?
Questo è sicuramente un bel problema, l’unico consiglio che posso dare è quello di scegliere la materia che più può interessare e per farlo può essere d’aiuto leggersi gli esami e le loro descrizioni nella guida dello studente di ogni facoltà. Un vasto elenco delle varie ingegnerie che esistono è presente su Wikipedia.
Per quanto riguarda gli esami, il primo anno è praticamente uguale per tutte le ingegnerie: Analisi I, Analisi II, Geometria e algebra, Fisica I, Fisica II, Informatica, Disegno, e Chimica. Sono gli strumenti di base che servono ad un qualsiasi ingegnere e non vanno sottovalutati. Dal secondo anno in poi gli esami iniziano a diventare più specifici e finalmente si ha a che fare con le materie che costituiranno il pane quotidiano per il resto della carriera universitaria!

Un’altra questione che terrorizza chi si vuole iscrivere a ingegneria è: Quanto devo studiare?
La risposta è semplice: tanto. Questo «tanto» non è comunque in alcun modo paragonabile allo studio delle scuole superiori. Alle superiori si è costretti a studiare materie che spesso non ci interessano neanche lontanamente e inoltre si utilizza un metodo di studio che non sempre è adatto anche all’università. A ingegneria si studiano le materie che più ci interessano e quindi anche se passi giornate intere sui libri lo fai con piacere, perché studi argomenti che ti appassionano. È per questo che bisogna fare molta attenzione alla scelta della facoltà, perché una scelta sbagliata porta inesorabilmente al fallimento. Se non c’è passione, studiare diventa impossibile.
Volendo quantificare un po’ quel «tanto»: 3-4 ore durante il periodo dei corsi e 9-10 ore durante il periodo degli esami.
Per uno studente liceale abituato a studiare un paio d’ore a settimana questi numeri possono spaventare ma, ripeto, lo studio che si fa al liceo non è paragonabile allo studio che si fa all’unviersità.

Per quanto possa sembrare banale, un consiglio che vorrei darvi se vi iscrivete a ingegneria, è quello di studiare tutti i giorni, anche durante i corsi. Sì, è una cosa che dicono dalle scuole elementari, ma non lo capisci finquando non arrivi all’università! Ridursi a studiare gli esami 15-20 giorni prima è difficile, è molto stancante e non permette di stare al passo con gli altri esami. Anche una semplice lettura degli appunti presi in classe, per capire meglio i concetti spiegati, può aiutare tantissimo quando ci si ritrova a dover sostenere cinque esami in due mesi.

Gli ultimi due argomenti di cui volevo parlare sono professori e voti. Il primo esame è sempre quello più difficile, perché si pensa al docente universitario come ad una chissà quale entità aliena dalla conoscenza assoluta alla quale non è possibile rivolgersi in alcun modo. No. I professori universitari sono esseri umani (già)! E spesso con loro si instaura un rapporto persino migliore di quello che si aveva con i professori al liceo. Magari con una classe di trecento allievi può essere più difficile, ma dal secondo anno in poi spesso non si superano le cinquanta persone per aula.
I professori mettono a disposizione un orario di ricevimento che consiglio di utilizzare, infatti la maggior parte di loro è molto ben disposta a dare spiegazioni.
I voti, infine, sono forse l’argomento più difficile da trattare. C’è chi preferisce mantenere una media alta e ci mette una vita a laurearsi, chi accetta tutto e si laurea in poco tempo. Poi ci sono le vie di mezzo e i casi particolari. Il voto è sì importante, ma non deve diventare un’ossessione. Spesso i professori si indispettiscono quando uno studente rifiuta un voto e, assieme al fatto che è difficile (e soprattutto noioso) studiare due o più volte uno stesso esame, capita che lo studente è costretto ad accettare un voto persino inferiore a quello che aveva rifiutato.
Prendersi un po’ più di tempo per avere un voto migliore può andare bene, ma le aziende spesso preferiscono assumere persone laureate in meno tempo, piuttosto che con un voto appena migliore ma laureate in più tempo. Per questo motivo bisogna trovare il giusto compromesso tra voti e tempo, per laurearsi con i voti più alti possibili nel minor tempo possibile, in modo da avere un’efficienza massima. Ovviamente questo rapporto dipende dalle capacità dello studente.

Un appunto infine per quanto riguarda quella specie di “test d’ingresso” che hanno proposto da un paio d’anni ai neoiscritti. È molto facile superarlo se avete conoscenze in matematica e può essere superato anche se si hanno conoscenze in altre materie. Se non doveste passarlo potete iscrivervi tranquillamente a ingegneria, solo che non potrete fare l’esame di Analisi I finquando non passerete questo test. Anche se non avete alcuna conocenza in matematica, dopo aver seguito i corsi del primo semestre, superarlo sarà una passeggiata . Il suo obiettivo è quello di «spaventare» tutti quelli che si iscrivono a ingegneria solo perché “Si dice che si trova lavoro“. Non lasciatevi ingannare dall’esito del test d’ingresso, né tantomeno dal voto dell’esame di maturità. Se avete passione per la materia che state per affrontare e siete pronti a studiare, riuscirete senza troppi problemi.

Per ulteriori domande potete utilizzare i commenti .

Purtroppo a causa della mancanza di tempo non sono riuscito a completarla e sono presenti alcuni bug che segnalo stesso in questa pagina:

• I dati sulla pressione e la temperatura nella stratosfera non vengono calcolati correttamente
• Il calcolo del centro aerodinamico dell’ala non è corretto in caso di angolo di freccia
• Il calcolo del coefficiente di momento non è corretto
• È possibile settare i dati del piano di coda orizzontale, ma questi non vengono ancora utilizzati per fare calcoli

L’applicazione è comunque in grado di calcolare svariati parametri geometrici e aerodinamici sull’ala, impostandone caratteristiche alla radice e all’estremità.

Segue il codice del programma.

import e32
import graphics
import appuifw
from random import randint
from math import sqrt, sin, cos, tan, atan, log10, ceil, pi, e as E

def draw(r=None):
    """Draw the buffer on the canvas"""
    if buffer:
        c.blit(buffer)

c = appuifw.Canvas(redraw_callback=draw)
buffer = graphics.Image.new(c.size)
appuifw.app.body = c
width, height = c.size
# airfoil contains [NACA, digit, (t, m, p)]
# wing_G contains geometrical parameters about wing (b, br, ct, boh)
# wing_A contains aerodynamical parameters about wing (boh, ancora più boh)
airfoil = [None, None, [0, 0, 0]]
wing_G = [10., # Wingspan
          1.6, # Chord root
          0.8, # Chord tip
          15., # Sweep angle
          3.0, # Wing incidence
          0.9, # Efficiency number
         -3.0] # Twist angle

wing_A = [
        # Root
         [0.11,  # Alfa lift coefficient
           -0.07, # Zero-lift moment coefficient
           -1.0,  # Alfa zero lift
           0.25], # Aerodynamic center position
        # Tip
          [0.105, # Clat
           -0.08, # Cm0t
           -2.5,  # azlt
           0.23]  # xact
        ]
fuselage = [-0.05,  # Zero lift moment coefficient
            0.0035] # Alpha moment coefficient
tail = [[], # Horizontal
        []] # Vertical

def derivative(func, x):
    """Derivates a function in a point"""
    return (func(x) - func(x+0.001))/0.001

def integrate(func, interval):
    """Trapezoidal numerical integration"""
    a, b = interval
    a = float(a)
    b = float(b)
    # Splits interval in 500 points per unit
    if abs(b - a) < 1e-5:
        return 0
    points = (b - a)*500.0
    increment = (b - a)/points
    area = 0.0
    for i in xrange(points):
        i = float(i)
        x = b * i/points + a * (1.0 - i/points)
        # Jump a possibile discontinuity
        try:
            area += (func(x+increment) + func(x)) * increment / 2.0
        except:
            pass
    return area

def mean_line(x, airfoil):
    """Airfoil mean line function"""
    digit = airfoil[1]
    t, m, p = airfoil[2]
    if digit == 4:
        if p < 1e-5:
            return 0
        elif x <= p:
            return m / (p**2) * (2*p*x - x**2)
        elif x > p:
            return m * (1 - 2*p + 2*p*x - x**2) / ((1 - p)**2)
    elif digit == 5:
        if x <= m:
            return p / 6 * (x**3 - 3*m*x**2 + m**2 * (3 - m)*x)
        elif x > m:
            return p * m**3 / 6*(1 - x)

def thickness(x, airfoil):
    """Airfoil thickness function"""
    t = airfoil[2][0]
    return t / 0.2 * (+0.2969 * x**0.5 +
                      -0.1260 * x**1 +
                      -0.3516 * x**2 +
                      +0.2843 * x**3 +
                      -0.1015 * x**4)

def NACA_set():
    """Set NACA to operate"""
    global airfoil
    NACA = appuifw.query(u'Insert 4-5 digit NACA', 'number')
    if NACA:
        digit = ceil(log10(NACA))
        # Digit correction for 00XX and 000X
        if digit in [1, 2, 3]: digit = 4
        t = (NACA%100)/100. # Thickness
        if digit == 4:
            m = (NACA/1000)/100. # Max camber
            p = (NACA/100-NACA/1000*10)/10. # Max camber position
            airfoil = [NACA, digit, (t, m, p)]
            NACA_plot()
        elif digit == 5:
            mean_line_datas = {210:[0.0580, 361.4],
                               220:[0.1260, 51.64],
                               230:[0.2025, 15.957],
                               240:[0.2900, 6.643],
                               250:[0.3910, 3.230]}
            try:
                m = mean_line_datas[NACA/100][0]
                p = mean_line_datas[NACA/100][1]
                airfoil = [NACA, digit, (t, m, p)]
                NACA_plot()
            except KeyError:
                appuifw.note(u'NACA not supported!', 'error')
        else:
            appuifw.note(u'NACA must be 4 or 5 digit!', 'error')
    else:
        appuifw.note(u'NACA must be 4 or 5 digit!', 'error')

def NACA_plot():
    """Plots a NACA"""
    if not airfoil[0]:
        NACA_set()
        if not airfoil[0]:
            return
    buffer.clear()
    # NACA parameters
    NACA, digit, N = airfoil
    font = (None, 30)
    color0 = (0, 0, 0) # Text color
    color1 = (0, 0, 255) # Airfoil color
    color2 = (255, 0, 0) # Meanline color
    color3 = (100, 100, 100) # Radius color
    # Draws the axes
    s_width = width - 10 # Scaled width, for the border
    y0 = height/2 # Origin of axes
    buffer.line((0, y0, width, y0), outline=color0)
    # Draws the scale
    unit = 10 # Axis will be divided into %unit part
    for u in range(11):
        buffer.line((5 + u * s_width / unit, y0 - 2,
                     5 + u * s_width / unit, y0 + 2),
                     outline=color0)
    # Unit legend
    buffer.line((10, 2*y0 - 20,
                 10 + s_width/unit, 2*y0 - 20),
                 outline=color0)
    buffer.text((20 + s_width/unit, 2*y0 - 15),
                 u'%d%% of the chord' % (100/unit),
                 fill=color0)
    # Displays infos about the airfoil
    radius = 1.1019 * N[0]**2
    radius_pos = (5, y0 - radius*s_width,
                  5 + radius*s_width*2, y0 + radius*s_width)
    buffer.ellipse(radius_pos, outline=color3)
    buffer.text((10, 30), u'NACA %0#4d' % NACA, font=font, fill=color0)
    buffer.text((10, 55), u'LE radius: %.4f' % radius, fill=color0)
    # Plot
    for x in xrange(s_width):
        x = float(x)/s_width
        # xx is an increment of x to calculate next point of each segment
        xx = (x * s_width + 1) / s_width
        # Meanline
        xM_1 = 5 + x * s_width
        yM_1 = y0 - mean_line(x, airfoil) * s_width
        xM_2 = 5 + xx * s_width
        yM_2 = y0 - mean_line(xx, airfoil) * s_width
        buffer.line((xM_1, yM_1, xM_2, yM_2), outline=color2)
        # Airfoil (U: Upper, L: Lower, 1-2 are 1st and 2nd point of the line)
        teta = atan(derivative(lambda x: mean_line(x, airfoil), x))
        xU_1 = 5 + (x - thickness(x, airfoil)*sin(teta)) * s_width
        yU_1 = y0 - (mean_line(x, airfoil) -
                    thickness(x, airfoil)*cos(teta)) * s_width
        xL_1 = 5 + (x + thickness(x, airfoil)*sin(teta)) * s_width
        yL_1 = y0 - (mean_line(x, airfoil) +
                    thickness(x, airfoil)*cos(teta)) * s_width
        xU_2 = 5 + (xx - thickness(xx, airfoil)*sin(teta)) * s_width
        yU_2 = y0 - (mean_line(xx, airfoil) -
                    thickness(xx, airfoil)*cos(teta)) * s_width
        xL_2 = 5 + (xx + thickness(xx, airfoil)*sin(teta)) * s_width
        yL_2 = y0 - (mean_line(xx, airfoil) +
                    thickness(xx, airfoil)*cos(teta)) * s_width
        buffer.line((xU_1, yU_1, xU_2, yU_2), outline=color1, width=2)
        buffer.line((xL_1, yL_1, xL_2, yL_2), outline=color1, width=2)
    draw()

def NACA_export():
    """Export NACA plot as image"""
    if not airfoil[0]:
        NACA_set()
        if not airfoil[0]:
            return
    new_width = appuifw.query(u'Image width (px)', 'number', 800)
    new_height = new_width / 1.4
    image = graphics.Image.new((new_width, new_height))
    image.clear()
    # NACA parameters
    NACA, digit, N = airfoil
    font = (None, 30)
    color0 = (0, 0, 0) # Text color
    color1 = (0, 0, 255) # Airfoil color
    color2 = (255, 0, 0) # Meanline color
    color3 = (100, 100, 100) # Radius color
    # Draws the axes
    s_width = new_width - 10 # Scaled width, for the border
    y0 = new_height/2 # Origin of axes
    image.line((0, y0, new_width, y0), outline=color0)
    # Draws the scale
    unit = 10 # Axis will be divided into %unit part
    for u in range(11):
        image.line((5 + u * s_width / unit, y0 - 2,
                    5 + u * s_width / unit, y0 + 2),
                    outline=color0)
    # Unit legend
    image.line((10, 2*y0 - 20,
                 10 + s_width/unit, 2*y0 - 20),
                 outline=color0)
    image.text((20 + s_width/unit, 2*y0 - 15),
                 u'%d%% of the chord' % (100/unit),
                 fill=color0)
    # Displays infos about the airfoil
    radius = 1.1019 * N[0]**2
    radius_pos = (5, y0 - radius*s_width,
                  5 + radius*s_width*2, y0 + radius*s_width)
    image.ellipse(radius_pos, outline=color3)
    image.text((10, 30), u'NACA %0#4d' % NACA, font=font, fill=color0)
    image.text((10, 55), u'LE radius: %.4f' % radius, fill=color0)
    # Plot
    for x in xrange(s_width):
        x = float(x)/s_width
        # xx is an increment of x to calculate next point
        xx = (x * s_width + 1) / s_width
        # Meanline
        xM_1 = 5 + x * s_width
        yM_1 = y0 - mean_line(x, airfoil) * s_width
        xM_2 = 5 + xx * s_width
        yM_2 = y0 - mean_line(xx, airfoil) * s_width
        image.line((xM_1, yM_1, xM_2, yM_2), outline=color2)
        # Airfoil (U: Upper, L: Lower, 1-2 are 1st and 2nd point of the line)
        teta = atan(derivative(lambda x: mean_line(x, airfoil), x))
        xU_1 = 5 + (x - thickness(x, airfoil)*sin(teta)) * s_width
        yU_1 = y0 - (mean_line(x, airfoil) -
                    thickness(x, airfoil)*cos(teta)) * s_width
        xL_1 = 5 + (x + thickness(x, airfoil)*sin(teta)) * s_width
        yL_1 = y0 - (mean_line(x, airfoil) +
                    thickness(x, airfoil)*cos(teta)) * s_width
        xU_2 = 5 + (xx - thickness(xx, airfoil)*sin(teta)) * s_width
        yU_2 = y0 - (mean_line(xx, airfoil) -
                    thickness(xx, airfoil)*cos(teta)) * s_width
        xL_2 = 5 + (xx + thickness(xx, airfoil)*sin(teta)) * s_width
        yL_2 = y0 - (mean_line(xx, airfoil) +
                    thickness(xx, airfoil)*cos(teta)) * s_width
        image.line((xU_1, yU_1, xU_2, yU_2), outline=color1, width=2)
        image.line((xL_1, yL_1, xL_2, yL_2), outline=color1, width=2)
    file_name = appuifw.query(u'Insert file name', 'text', u'.png')
    file_path = u'C:\\%s' % file_name
    image.save(file_path)
    del image
    appuifw.note(u'Image saved at C:\\%s' % file_name, 'info')
    # Ask if want to send the file
    if appuifw.query(u'Send the file via BT?', 'query'):
        try:
            import btsocket as socket
        except ImportError:
            import socket
        address, services = socket.bt_obex_discover()
        channel = services.items()[0][1]
        try:
            socket.bt_obex_send_file(address, channel, file_path)
        except error:
            appuifw.note(error.decode('utf-8'), 'error')

def ISA(z):
    """International standard atmosphere"""
    T_sl = 288.15 # Kelvin
    p_sl = 101325.0 # Pascal
    rho_sl = 1.225 # kg/m^3
    # Air gas constant: 287 J / (kg * K)
    T = T_sl - 6.5 * (z/1000.0) # Thermal gradient: -6.5 K/km
    p = p_sl * (T/T_sl) ** (9.81 / 287 / 6.5e-3)
    rho = rho_sl * (T/T_sl) ** (9.81 / 287 / 6.5e-3 - 1)
    # Troposphere
    #if z < 11000:
    #    T = T_sl - 6.5 * (z/1000.0) # Thermal gradient: -6.5 K/km
    #    p = p_sl * (T/T_sl) ** (9.81 / 287 / 6.5e-3)
    #    rho = rho_sl * (T/T_sl) ** (9.81 / 287 / 6.5e-3 - 1)
    ## Stratosphere
    #elif z >= 11000 and z < 20000:
    #    T = 216.65
    #    p = 2270 * E ** (-9.81 / 287 / 6.5e-3 * (z-11000))
    #    rho = 0.2978 * E ** (-9.81 / 287 / 6.5e-3 * (z-11000))
    #elif z >= 20000:
    #    # Up 20000 m thermal gradient is approximated
    #    T = 216.65 + 0.98 * (z-20000)/1000.0 # Thermal gradient: ~ 0.98 K/km
    #    p = 2270 * E ** (-9.81 / 287 / 6.5e-3 * (z-11000))
    #    rho = 0.2978 * E ** (-9.81 / 287 / 6.5e-3 * (z-11000))
    return (T, p, rho)

def Reynolds():
    """Shows a form to calculate dimensionless quantity"""
    fields = [(u'Speed [m/s]', 'float', 0.0),
              (u'Density [kg/m^3]', 'float', 0.0),
              (u'D. viscosity [Pa*s]', 'float', 0.0),
              (u'Linear dimension [m]', 'float', 0.0)]
    flag = appuifw.FFormEditModeOnly + appuifw.FFormDoubleSpaced
    form = appuifw.Form(fields, flag)
    form.execute()
    # Result
    speed, density, viscosity, linear_d = [i[2] for i in list(form)]
    reynolds = density * speed * linear_d / viscosity
    appuifw.query(u'Reynolds:', 'text', unicode(reynolds))
    appuifw.query(u'Reynolds (exp):', 'text', u'%.0e' % reynolds)

def Mach():
    """Shows a form to calculate dimensionless quantity"""
    fields = [(u'Speed [m/s]', 'float', 0.0),
              (u'Sound speed [m/s]', 'float', 0.0),
              (u'* Temperature [degC]', 'float', 0.0),
              (u'* Altitude [m]', 'float', 0.0)]
    flag = appuifw.FFormEditModeOnly + appuifw.FFormDoubleSpaced
    form = appuifw.Form(fields, flag)
    appuifw.note(u'You may use temp. or alt. instead of sound speed', 'info')
    form.execute()
    # Result
    speed, sound_speed, temperature, altitude = [i[2] for i in list(form)]
    if sound_speed < 1e-5:
        if temperature != 0.0:
            # Air gas constant: 287 J / (kg * K)
            sound_speed = (1.4 * 287 * (273.15+temperature)) ** 0.5
        elif altitude != 0.0:
            sound_speed = (1.4 * 287 * ISA(altitude)[0]) ** 0.5
        else:
            appuifw.note(u'Not enough parameters', 'error')
    mach = speed / sound_speed
    appuifw.query(u'Mach:', 'text', unicode(mach))

def Froude():
    """Shows a form to calculate dimensionless quantity"""
    fields = [(u'Speed [m/s]', 'float', 0.0),
              (u'\u0394 z [m]', 'float', 0.0),
              (u'Gravity [m/s^2]', 'float', 9.81)]
    flag = appuifw.FFormEditModeOnly + appuifw.FFormDoubleSpaced
    form = appuifw.Form(fields, flag)
    form.execute()
    # Result
    speed, linear_d, gravity = [i[2] for i in list(form)]
    froude = speed * speed / gravity / linear_d
    appuifw.query(u'Froude:', 'text', unicode(froude))

def wing_set(type, par):
    """
    Set the geometrical or aerodynamical parameters for the wing
    type can be:
        - 'geom': geometrical parameters
        - 'aero_r': aerodynamic of root chord
        - 'aero_t': aerodynamic of tip chord

    wing_G contains:
        - b: wingspan
        - cr: chord at root
        - ct: chord at tip
        - sweep: sweep angle from leading edge
        - iw: angle of incidence of wing (at root chord)
        - ew: efficiency number for non-elliptical wings
        - eps: angle of twist

    wing_A cointains:
        - wing_A[0]: aerodynamical parameters at root chord
        - wing_A[1]: aerodynamical parameters at tip chord
    parameters ending with *r are referred to the root chord
    parameters ending with *t are referred to the tip chord
    """
    global wing_G, wing_A, fuselage, tail
    # Set geometrical parameters
    if type == 'geom':
        # Set all parameters
        if par == 'all':
            fields = [(u'Wingspan [m]', 'float', wing_G[0]),
                      (u'Chord root [m]', 'float', wing_G[1]),
                      (u'Chord tip [m]', 'float', wing_G[2]),
                      (u'Sweep angle [deg]', 'float', wing_G[3]),
                      (u'Wing incidence [deg]', 'float', wing_G[4]),
                      (u'Efficiency number [ ]', 'float', wing_G[5]),
                      (u'Twist angle [deg]', 'float', wing_G[6])]
            flag = appuifw.FFormEditModeOnly + appuifw.FFormDoubleSpaced
            form = appuifw.Form(fields, flag)
            form.execute()
            # Result
            wing_G = b, cr, ct, sweep, iw, ew, eps = [i[2] for i in list(form)]
        # Set a specific parameter
        elif par == 'wingspan':
            b = appuifw.query(u'Set wingspan [m]:', 'float', wing_G[0])
            wing_G[0] = b
        elif par == 'chords':
            cr = appuifw.query(u'Set root chord [m]:', 'float', wing_G[1])
            ct = appuifw.query(u'Set tip chord [m]:', 'float', wing_G[2])
            wing_G[1] = cr
            wing_G[2] = ct
        elif par == 'sweep':
            sweep = appuifw.query(u'Set sweep [deg]:', 'float', wing_G[3])
            wing_G[3] = sweep
        elif par == 'incid':
            incidence = appuifw.query(u'Set wing incidence [deg]:',
                                      'float', wing_G[4])
            wing_G[4] = incidence
        elif par == 'effic':
            effic = appuifw.query(u'Set efficiency number [ ]:',
                                  'float', wing_G[5])
            wing_G[5] = effic
        elif par == 'twist':
            twist = appuifw.query(u'Set twist angle [deg]:',
                                  'float', wing_G[6])
            wing_G[6] = twist
        wing_draw()
    # Set aerodynamical parameters for root
    elif type == 'aero_r':
        # Set all parameters
        if par == 'all':
            fields = [(u'Alfa lift coeff. [1/deg]', 'float', wing_A[0][0]),
                      (u'Zero-lift moment coeff. [ ]', 'float', wing_A[0][1]),
                      (u'Alfa zero lift [deg]', 'float', wing_A[0][2]),
                      (u'Aero. center pos. [of Cr]', 'float', wing_A[0][3])]
            flag = appuifw.FFormEditModeOnly + appuifw.FFormDoubleSpaced
            form = appuifw.Form(fields, flag)
            form.execute()
            # Result
            wing_A[0] = Clar, Cm0r, azlr, xacr = [i[2] for i in list(form)]
        # Set a specific parameter
        elif par == 'copy':
            wing_A[0] = wing_A[1]
        elif par == 'Clar':
            Clar = appuifw.query(u'Set alfa lift coeff. [1/deg]:',
                                 'float', wing_A[0][0])
            wing_A[0][0] = Clar
        elif par == 'Cm0r':
            Cm0r = appuifw.query(u'Set zero-lift moment coeff. [ ]:',
                                 'float', wing_A[0][1])
            wing_A[0][1] = Cm0r
        elif par == 'azlr':
            azlr = appuifw.query(u'Set alfa zero lift [deg]:',
                                 'float', wing_A[0][2])
            wing_A[0][2] = azlr
        elif par == 'xacr':
            xacr = appuifw.query(u'Set aero. center pos. [of Cr]:',
                                 'float', wing_A[0][3])
            wing_A[0][3] = xacr
    # Set aerodynamical parameters for tip
    elif type == 'aero_t':
        # Set all parameters
        if par == 'all':
            fields = [(u'Alfa lift coeff. [1/deg]', 'float', wing_A[1][0]),
                      (u'Zero-lift moment coeff. [ ]', 'float', wing_A[1][1]),
                      (u'Alfa zero lift [deg]', 'float', wing_A[1][2]),
                      (u'Aero. center pos. [of Ct]', 'float', wing_A[1][3])]
            flag = appuifw.FFormEditModeOnly + appuifw.FFormDoubleSpaced
            form = appuifw.Form(fields, flag)
            form.execute()
            # Result
            wing_A[1] = Clat, Cm0t, azlt, xact = [i[2] for i in list(form)]
        # Set a specific parameter
        elif par == 'copy':
            wing_A[1] = wing_A[0]
        elif par == 'Clat':
            Clat = appuifw.query(u'Set alfa lift coeff. [1/deg]:',
                                 'float', wing_A[1][0])
            wing_A[1][0] = Clat
        elif par == 'Cm0t':
            Cm0t = appuifw.query(u'Set Zero-lift moment coeff. [ ]:',
                                 'float', wing_A[1][1])
            wing_A[1][1] = Cm0t
        elif par == 'azlt':
            azlt = appuifw.query(u'Set alfa zero lift [deg]:',
                                 'float', wing_A[1][2])
            wing_A[1][2] = azlt
        elif par == 'xact':
            xact = appuifw.query(u'Set aero. center pos.[of Ct]:',
                                 'float', wing_A[1][3])
            wing_A[1][3] = xact
    # Set fuselage parameters
    if type == 'fuse':
        fields = [(u'Zero-lift Moment coeff. [ ]', 'float', fuselage[0]),
                  (u'Alpha moment coeff. [1/deg]', 'float', fuselage[1])]
        flag = appuifw.FFormEditModeOnly + appuifw.FFormDoubleSpaced
        form = appuifw.Form(fields, flag)
        form.execute()
        # Result
        fuselage = Cm0f, Cmaf = [i[2] for i in list(form)]
    # Set tail parameters
    if type == 'tail_h':
        fields = [(u'Alfa lift coeff. 2D [1/deg]', 'float', tail[0][0]),
                  (u'Wingspan [m]', 'float', tail[0][1]),
                  (u'Surface [m^2]', 'float', tail[0][2]),
                  (u'Efficiency number [ ]', 'float', tail[0][3]),
                  (u'Dinamic pressures ratio [ ]', 'float', tail[0][4])]
        flag = appuifw.FFormEditModeOnly + appuifw.FFormDoubleSpaced
        form = appuifw.Form(fields, flag)
        form.execute()
        # Result
        fuselage = Cm0f, Cmaf = [i[2] for i in list(form)]

def wing_draw():
    """Draws the wing."""
    if not any(wing_G):
        wing_set('geom', 'all')
        if not any(wing_G):
            return
    b, cr, ct, sweep, iw, ew, eps = wing_G
    WC = lambda y: cr + y * (ct - cr) * 2.0/b # Wing chord distribution
    buffer.clear()
    font = (None, 30)
    color0 = (0, 0, 0) # Text color
    color1 = (0, 0, 255) # Wing color
    color2 = (255, 0, 0) # Chords color
    color3 = (150, 150, 150) # Legend color
    s_width = width - 10 # Scaled width, for the border
    # Dimensionless ratio
    if cr > b/2:
        DLR = height/2 / cr
    else:
        DLR = s_width / b
    b, cr, ct = [(i * DLR) for i in (b, cr, ct)]
    # Draws axes
    y0 = height/3 # Origin of axes
    x0 = width/2
    buffer.line((0, y0, width, y0), outline=color0)
    buffer.line((x0, 0, x0, height), outline=color0)
    #  Right leading edge
    RLE = (x0, y0,
              x0 + b/2, y0 + b/2 * tan(sweep*pi/180))
    # Right trailing edge
    RTE = (x0 + b/2, y0 + b/2 * tan(sweep*pi/180) + ct,
             x0, y0 + cr)
    # Left tip chord
    LTC = (x0 - b/2, y0 + b/2 * tan(sweep*pi/180) + ct,
             x0 - b/2, y0 + b/2 * tan(sweep*pi/180))
    # Draws left/right wings
    buffer.polygon(RLE + RTE + LTC, outline=color1, width=2)
    # Calculates the Mean Aerodynamic Chord
    # I divide by DLR, so I can integrate for smaller intervals
    b, cr, ct = [(i / DLR) for i in (b, cr, ct)]
    Sw = 2 * integrate(lambda y: WC(y), (0, b/2))
    MAC = 2 / Sw * integrate(lambda y: WC(y)**2, (0, b/2)) * DLR
    y_MAC = 2 / Sw * integrate(lambda y: y * WC(y), (0, b/2)) * DLR
    b, cr, ct = [(i * DLR) for i in (b, cr, ct)]
    # Draws the MAC
    points = (x0 + y_MAC, y0 + (b/2 - y_MAC) * tan(sweep*pi/180),
              x0 + y_MAC, y0 + (b/2 - y_MAC) * tan(sweep*pi/180) + MAC)
    buffer.line(points, outline=color2, width=2)
    # Shows the legend
    line_MAC = (x0 + y_MAC, y0 + (b/2 - y_MAC) * tan(sweep*pi/180),
                x0 + y_MAC, y0 - 20)
    text_MAC = (x0 + y_MAC, y0 - 20)
    buffer.line(line_MAC, outline=color3)
    buffer.text(text_MAC, u'M.A.C.', fill=color3)
    draw()

def wing_info(type):
    """
    Calculates and shows geometrical informations about the wing.
    type can be:
        - 'geom': shows geometrical info
        - 'aero': shows aerodynamic info
    wing_A cointains:
        - wing_A[0]: aerodynamical parameters at root chord
        - wing_A[1]: aerodynamical parameters at tip chord
    parameters ending with *r are referred to the root chord
    parameters ending with *t are referred to the tip chord

    "eps" is the twist angle, while "twist" is the law of twist
    """
    # Geometrical info
    if type == 'geom':
        if not wing_G: wing_set('geom', 'all')
        b, cr, ct, sweep, iw, ew, eps = wing_G
        WC = lambda y: cr + y * (ct - cr) * 2.0/b # Wing chord distribution
        Sw = 2 * integrate(lambda y: WC(y), (0, b/2))
        AR = b**2 / Sw # Aspect ratio
        TR = ct / cr   # Taper ratio
        MAC = 2 / Sw * integrate(lambda y: WC(y)**2, (0, b/2))
        y_MAC = 2 / Sw * integrate(lambda y: y * WC(y), (0, b/2))
        fields = [
            (u'Aspect ratio [ ]', 'text', u'%.2f' % AR),
            (u'Tape ratio [ ]', 'text', u'%.2f' % TR),
            (u'Wing surface [m^2]', 'text', u'%.2f' % Sw),
            (u'Mean Aerodynamic Chord [m]', 'text', u'%.2f' % MAC),
            (u'y of M.A.C. [% of wing]', 'text', u'%.1f' % (y_MAC * 200 / b))]
        flag = appuifw.FFormDoubleSpaced
        form = appuifw.Form(fields, flag)
        form.execute()
    # Aerodynamical info
    elif type == 'aero':
        if not wing_A: wing_set('aero', 'all')
        # Load geometric and aerodynamic parameters
        b, cr, ct, sweep, iw, ew, eps = wing_G
        WC = lambda y: cr + y * (ct - cr) * 2.0/b # Wing chord distribution
        Clar, Cm0r, azlr, xacr = wing_A[0]
        Clat, Cm0t, azlt, xact = wing_A[1]
        # Laws of variation from root to tip
        Cla = lambda y: Clar + y * (Clat - Clar) / (b/2)
        Cm0 = lambda y: Cm0r + y * (Cm0t - Cm0r) / (b/2)
        azl = lambda y: azlr + y * (azlt - azlr) / (b/2)
        xac = lambda y: xacr + y * (xact - xacr) / (b/2)
        twist = lambda y: y * eps / (b/2)
        # Lift coefficient of 2D wing (without downwash), weighted mean
        par = (b, cr, ct)
        integ = lambda y: WC(y)
        Sw = 2 * integrate(integ, (0, b/2))
        integ = lambda y: Cla(y) * WC(y)
        Claw = 2 / Sw * integrate(integ, (0, b/2))
        # Lift coefficient of 3D wing (elliptical wing formula)
        AR = b**2 / Sw
        if not ew: ew = 1 # Elliptical wing
        CLa = Claw / (1 + (57.296*Claw/pi/ew/AR))
        # Alfa zero Lift of wing
        integ = lambda y: (azl(y) - twist(y)) * WC(y)
        azL = 2 / Sw * integrate(integ, (0, b/2))
        # Moment coefficient (AC) of wing
        MAC = 2 / Sw * integrate(lambda y: WC(y)**2, (0, b/2))
        integ = lambda y: (Cm0(y) * WC(y)**2 -
                           pi * (azL - twist(y) - azl(y)) * WC(y) * xac(y))
        Cmacw = 2 / (Sw * MAC) * integrate(integ, (0, b/2))
        # Aerodynamic center
        integ = lambda y: Cla(y) * xac(y) * WC(y)
        xAC = (2 / Sw / CLa * integrate(integ, (0, b/2)))
        integ = lambda y: Cla(y) * y * WC(y)
        yAC = 2 / Sw / CLa * integrate(integ, (0, b/2))
        # Show results
        fields = [
            (u'Lift coefficient of 2D wing [1/deg]', 'text', u'%.4f' % Claw),
            (u'Lift coefficient of 3D wing [1/deg]', 'text', u'%.4f' % CLa),
            (u'Moment coefficient (AC) of wing [ ]', 'text', u'%.4f' % Cmacw),
            (u'Alfa zero Lift of wing [deg]', 'text', u'%.3f' % azL),
            (u'x of aero. center [%MAC]', 'text', u'%.2f' % xAC),
            (u'y of aero. center [%b]', 'text', u'%.2f' % yAC)]
        flag = appuifw.FFormDoubleSpaced
        form = appuifw.Form(fields, flag)
        form.execute()

def rotate_screen():
    """Rotate the screen and rebuilt the canvas"""
    global width, height, c, buffer
    screen = appuifw.app.orientation
    if screen == 'landscape':
        appuifw.app.orientation = 'portrait'
    else:
        appuifw.app.orientation = 'landscape'
    del c
    c = appuifw.Canvas(redraw_callback=draw)
    width, height = c.size
    buffer = buffer.resize(c.size)

def set_altitude(um):
    """Set altitude (um is unit of measurement)"""
    if um == 'm':
        altitude = appuifw.query(u'Insert altitude [m]:', 'float')
        tab_4(altitude)
    elif um == 'ft':
        altitude_ft = appuifw.query(u'Insert altitude [ft]:', 'float')
        altitude = altitude_ft * 0.3048
        tab_4(altitude)
    if altitude == None:
        appuifw.note(u'Altitude not set!', 'error')
        return

def quit():
    e32.Ao_lock().signal()

def tab_0():
    """Starting graphics"""
    buffer.clear()
    color = ((0, 0, 0),
             (0, 255, 0),
             (0, 150, 0))
    font = ((u'Nokia Hindi TitleSmBd S6', 30),
            (u'Nokia Hindi TitleSmBd S6', 15),
            (u'Nokia Hindi TitleSmBd S6', 15))
    text = (u'NACA PyFoil',
            u'By Ale152',
            u'www.wirgilio.it')
    box = (buffer.measure_text(text[0], font[0]),
           buffer.measure_text(text[1], font[1]),
           buffer.measure_text(text[2], font[2]))
    position = (((width-box[0][0][2])/2, 30),
                ((width-box[1][0][2])/2, 50),
                ((width-box[2][0][2])/2, 65))
    buffer.text(position[0], text[0], font=font[0], fill=color[0])
    buffer.text(position[1], text[1], font=font[1], fill=color[2])
    buffer.text(position[2], text[2], font=font[2], fill=color[2])
    s_width = width - 40 # Scaled width, for the border
    airfoil = [None, None, (0.12, 0, 0)] # NACA intro
    for x in xrange(s_width):
        x = float(x)/s_width
        # Airfoil (U: Upper, L: Lower)
        xL = xU = 20 + x * s_width
        yU = height/2 - thickness(x, airfoil) * s_width
        yL = height/2 + thickness(x, airfoil) * s_width
        buffer.line((xU, yU, xL, yL), outline=color[1], width=2)
        buffer.point((xL, yL), outline=color[2], width=2)
    draw()

def tab_1():
    """NACA Plot tab"""
    if not airfoil[0]:
        buffer.clear()
        position = (10, 30)
        color1 = (0, 0, 100) # Text
        color2 = (0, 0, 0) # Axes
        color3 = (80, 80, 80) # Units
        color4 = (0, 0, 200) # Function
        buffer.text(position, u'Please set a NACA from menu', fill=color1)
        # Draws an axes system (origin in [w/3, h/2])
        for k in range(30):
            xA = k * width/30
            yA = height/2
            xO = width/3
            yO = k * (height-50)/30
            buffer.line((xA, yA-2, xA, yA+3), outline=color3)
            buffer.line((xO-2, 50+yO, xO+3, 50+yO), outline=color3)
        buffer.line((width/3, 50, width/3, height), outline=color2)
        buffer.line((0, height/2, width, height/2), outline=color2)
        # Draws a function
        for t in xrange(900):
            t = float(t)
            x = t * cos(t*pi/180) / 15
            y = t * sin(t*pi/180) / 15
            buffer.point((width/3 + x, height/2 + y), outline=color4, width=2)
        draw()
        return
    else:
        NACA_plot()

def tab_2():
    """Dimensionless goup form"""
    buffer.clear()
    position = (10, 30)
    color1 = (0, 0, 100)
    color2 = (200, 0, 0)
    buffer.text(position, u'Select a group from menu', fill=color1)
    draw()

def tab_3():
    """Wings"""
    buffer.clear()
    position = (10, 30)
    color1 = (0, 0, 100)
    color2 = (200, 0, 0)
    buffer.text(position, u'Set wing parameter from menu', fill=color1)
    draw()

def tab_4(altitude=None):
    """Shows a form to calculate ISA parameters"""
    if altitude == None:
        buffer.clear()
        position = (10, 30)
        color = (0, 0, 100)
        buffer.text(position, u'Please set altitude from menu', fill=color)
        font = (u'Nokia Hindi TitleSmBd S6', 30)
        isa_text = [u'International', u'Standard', u'Atmosphere']
        buffer.text((10, 70), isa_text[0], font=font, fill=color)
        buffer.text((30, 100), isa_text[1], font=font, fill=color)
        buffer.text((50, 130), isa_text[2], font=font, fill=color)
        draw()
        return
    temp, press, dens = ISA(altitude)
    fields = [(u'Temperature [K]', 'text', u'%.3f' % temp),
              (u'Temperature [degC]', 'text', u'%.3f' % (temp - 273.15)),
              (u'Pressure [Pa]', 'text', u'%.3f' % press),
              (u'Density [kg/m^3]', 'text', u'%.3f' % dens)]
    flag = appuifw.FFormDoubleSpaced
    form = appuifw.Form(fields, flag)
    form.execute()

def set_tab(index):
    """Set tab function"""
    if index == 0: # Starting
        tab_0()
        appuifw.app.menu = menu_0
    elif index == 1: # NACA Plot
        tab_1()
        appuifw.app.menu = menu_1
    elif index == 2: # Dim.less goup
        tab_2()
        appuifw.app.menu = menu_2
    elif index == 3: # ISA
        tab_3()
        appuifw.app.menu = menu_3
    elif index == 4: # ISA
        tab_4()
        appuifw.app.menu = menu_4

tabs = [u'Intro', u'Plot', u'Group', u'Wing', u'ISA']
appuifw.app.set_tabs(tabs, set_tab)

# Starting menu
menu_0 = [(u'Rotate screen', rotate_screen),
          (u'About', lambda: appuifw.note(u'Created by Ale152', 'info')),
          (u'Quit', quit)]
# NACA Plot menu
menu_1 = [(u'Set NACA', NACA_set),
          (u'Plot', NACA_plot),
          (u'Export IMG', NACA_export),
          (u'Rotate screen', rotate_screen),
          (u'Quit', quit)]
# Dim.less group menu
menu_2 = [(u'Reynolds', Reynolds),
          (u'Mach', Mach),
          (u'Froude', Froude),
          (u'Rotate screen', rotate_screen),
          (u'Quit', quit)]
# Wings menu
menu_3 = [(u'Set wing geom', (
              (u'All', lambda: wing_set('geom', 'all')),
              (u'Wingspan', lambda: wing_set('geom', 'wingspan')),
              (u'Chords', lambda: wing_set('geom', 'chords')),
              (u'Sweep', lambda: wing_set('geom', 'sweep')),
              (u'Incidence', lambda: wing_set('geom', 'incid')),
              (u'Efficiency', lambda: wing_set('geom', 'effic')),
              (u'Twist', lambda: wing_set('geom', 'twist')))),
          (u'Set wing aero (root)', (
              (u'All', lambda: wing_set('aero_r', 'all')),
              (u'Copy from tip', lambda: wing_set('aero_r', 'copy')),
              (u'Alfa lift coeff.', lambda: wing_set('aero_r', 'Clar')),
              (u'Alfa moment coeff.', lambda: wing_set('aero_r', 'Cm0r')),
              (u'Alfa zero lift', lambda: wing_set('aero_r', 'azlr')),
              (u'Aero. center pos.', lambda: wing_set('aero_r', 'xacr')))),
          (u'Set wing aero (tip)', (
              (u'All', lambda: wing_set('aero_t', 'all')),
              (u'Copy from root', lambda: wing_set('aero_t', 'copy')),
              (u'Alfa lift coeff.', lambda: wing_set('aero_t', 'Clat')),
              (u'Alfa moment coeff.', lambda: wing_set('aero_t', 'Cm0t')),
              (u'Alfa zero lift', lambda: wing_set('aero_t', 'azlt')),
              (u'Aero. center pos.', lambda: wing_set('aero_t', 'xact')))),
          (u'Set horiz. tail', (
              (u'All', lambda: wing_set('aero_t', 'all')),
              (u'Copy from root', lambda: wing_set('aero_t', 'copy')),
              (u'Alfa lift coeff.', lambda: wing_set('aero_t', 'Clat')),
              (u'Alfa moment coeff.', lambda: wing_set('aero_t', 'Cm0t')),
              (u'Alfa zero lift', lambda: wing_set('aero_t', 'azlt')),
              (u'Aero. center pos.', lambda: wing_set('aero_t', 'xact')))),
          (u'Show geom info', lambda: wing_info('geom')),
          (u'Show aero info', lambda: wing_info('aero')),
          (u'Draw wing', wing_draw),
          (u'Rotate screen', rotate_screen),
          (u'Quit', quit)]
# ISA menu
menu_4 = [(u'Set altitude', (
              (u'Meters', lambda: set_altitude('m')),
              (u'Feet', lambda: set_altitude('ft')))),
          (u'Rotate screen', rotate_screen),
          (u'Quit', quit)]

set_tab(0)
app_lock = e32.Ao_lock()
app_lock.wait()

È incredibile notare come l’elevatissima energia cinetica dei proiettili si trasformi in energia interna a causa dell’urto, portando la temperatura del proiettile fino a quella di fusione.

Mars500

L’esperimento durerà 520 giorni, di cui: 250 giorni per «arrivare» su Marte, 30 giorni per esplorare la superficie del pianeta e 240 giorni per il «rientro» sulla Terra.
L’equipaggio è composto da sei uomini:

• Diego Urbina, italo-colombiano, 26 anni
• Romain Charles, francese, 31 anni
• Alexey Sitev, russo, 38 anni
• Sukhrob Kamolov, russo, 37 anni
• Alexandr Smoleevskiy, russo, 32 anni
• Wang Yue, cinese, 27 anni

La simulazione avverrà interamente in una costruzione di 550 m³ di volume, isolata ermeticamente e divisa in moduli: il modulo medico, il modulo abitativo, il simulatore di atterraggio su Marte e il deposito, contenente frigorifero, palestra, sauna e giardino per gli esperimenti.

Durante tutta la simulazione l’equipaggio sarà costretto al totale isolamento. Durante il primo e l’ultimo mese della missione potranno comunicare con la Terra a voce, ma durante tutto il resto della missione potranno farlo esclusivamente tramite messaggi di testo, i quali arriveranno a destinazione con un ritardo anche superiore ai venti minuti!

L’esperimento sarà supervisionato dall’esterno mediante delle webcam disposte all’interno dei moduli e tutti i parametri medici, psicologici e fisici degli astronauti saranno costantemente monitorati e registrati.

Lo scopo di questo esperimento è quello di conoscere l’impatto fisico e soprattutto psicologico che gli astronauti subiranno durante un periodo così lungo di isolamento. In base all’esito di questa simulazione si deciderà se è possibile una reale missione con equipaggio umano su Marte. Tutti gli altri obiettivi scientifici che sono stati posti per Mars500 sono consultabili presso questo indirizzo.

Durante l’esperimento l’equipaggio sarà costretto a vivere come gli astronauti della Stazione Spaziale Internazionale: esercizi di ginnastica tutti i giorni per almeno un’ora al giorno, pranzi a base di cibo liofilizzato e possibili guasti simulati durante il viaggio.
Tempo fa sono già stati fatti esperimenti del genere, con simulazioni di 14 giorni nel 2007 e 105 giorni nel 2009. Questa però è la prima volta che viene simulata una missione su Marte full-lenght.

Per conoscere i vari sviluppi della missione è possibile seguire il canale su YouTube di ESA, sul quale verrà pubblicato un vero e proprio video diario. Nel seguente video, il primo pubblicato, Diego Urbina ci mostra dall’interno il luogo nel quale vivrà per i prossimi 17 mesi.

Senza dubbio questo esperimento è di grandissima importanza, perché sarebbe impensabile spedire un equipaggio umano in isolamento per quasi due anni nello spazio senza neanche conoscerne le conseguenze.

In questo articolo voglio mostrare come sia possibile eliminare un rumore sfruttando le caratteristiche fisiche del suono stesso. Il suono è una “vibrazione prodotta da un corpo in rapida e regolare oscillazione, che si propaga nell’aria o in altri mezzi elastici producendo una sensazione uditiva”, questa vibrazione si propaga sottoforma di disturbi di pressione consecutivi che assumono le caratteristiche di onde longitudinali.

Asse delle ascisse: tempo; asse delle ordinate: ampiezza dell'onda

Nell’immagine è rappresentato l’andamento della variazione pressione dovuta all’onda, prodotta da un suono a frequenza costante.

L’eliminazione del rumore si basa sul principio di sovrapposizione delle onde, secondo il quale due onde che si incontrano danno vita a un’onda la cui ampiezza è la somma delle due. Il concetto è chiaramente rappresentato nella seguente animazione:

In base a questo principio, se le due onde sono perfettamente identiche ma hanno ampiezza opposta, queste si annullano. Perciò, per eliminare un rumore, è sufficiente generare un «antirumore» che si annichilisca con il fastidioso suono. I due suoni, rumore e antirumore, devono provenire dalla stessa sorgente, in modo che tutti i disturbi di pressione possano essere eliminati.

Vediamo un semplicissimo esempio di eliminazione di un rumore utilizzando il software opensource Audacity, disponibile sia per sistemi Windows che GNU/Linux.
Apriamo Audacity e creiamo un nuovo suono da Generate -> Tone, impostiamo una frequenza di 1000 Hz per poterlo udire e lasciamo inalterati gli altri parametri. Creiamo una nuova traccia audio tramite Project -> New Audio Track e generiamo un altro suono utilizzando gli stessi parametri del primo. A questo punto, tramite lo strumento Zoom, andiamo a ingrandire le due tracce audio sino a poterne distinguere la forma dell’onda. Selezioniamo interamente una delle due tracce con Edit -> Select -> Cursor to End e clicchiamo sull’icona del Time Shift Tool. Tramite questo strumento è possibile spostare la traccia audio, quindi spostiamo la traccia selezionata fino a far coincidere esattamente la cresta di un’onda con la gola dell’altra, come nell’immagine:

Infine, spostate il bilanciamento di una traccia tutto a sinistra (L) e quello dell’altra tutto a destra (R).

A questo punto, collegate due casse uguali al vostro computer e disponetele una accanto all’altra. Riproducete il suono appena creato e posizionatevi davanti alle due casse: finché vi trovate in questa posizione il suono sarà praticamente impercettibile, se vi spostate più a destra o più a sinistra riuscirete invece a sentirlo.
L’effetto è mostrato anche in questo video girato da me:

Nel video purtroppo non sono riuscito a trovare il punto preciso in cui i due suoni che arrivano al microfono si annullano, perché l’ho girato con il cellulare e non avevo la possibilità di ascoltare il suono registrato durante la ripresa. È comunque possibile notare come varia l’intensità del suono semplicemente cambiando la posizione delle casse.

Il file audio utilizzato è scaricabile tramite il seguente link:
- Rumore.wav -

In questo esempio il rumore eliminato è un semplice suono a frequenza costante, ma ci consente di capire il principio su cui si basano sistemi molto più complessi di eliminazione del rumore, che invece di basarsi su suoni preregistrati analizzano il rumore identificandolo in base a determinati parametri e generano un suono uguale dall’ampiezza opposta, che annulla il rumore.

Avvertenza: può indurre una condizione di deliquio.

Un genere musicale nasce dall’esigenza di classificare delle band che non rientrano negli schemi di un’epoca, e quando si parla di progressive metal, la prima band che viene in mente sono senza dubbio i Dream Theater. Dire però che i Dream Theater rappresentino il progressive metal, è un po’ come affermare che Bach rappresenta la musica classica.
I Dream Theater sono senz’altro tra le band prog più conosciute, ma non sono certamente sufficienti a rappresentare un genere così vasto e particolare come il progressive metal.

La parola «metal» fa subito scattare in molte persone una serie di pregiudizi che probabilmente derivano dall’associazione del genere metal al sottogenere heavy metal, che ha ben poco a che fare con il prog. Infatti quando si parla di metal, i primi nomi che possono venire in mente a chi non ascolta il genere sono Iron Maiden, Metallica, Black Sabbath e simili, ma queste band hanno ben poco a che fare con il progressive metal. Vediamo grossomodo quali sono le caratteristiche che contraddistinguono il progressive metal.

Gli strumenti

Il prog è stato il primo genere metal a fare largo uso delle tastiere, che permettono di richiamare atmosfere tipiche del jazz e del blues, in genere assenti nel metal. Un esempio lampante è il progetto musicale Liquid Tension Experiment. Le tastiere vengono inoltre spesso associate a dei sintetizzatori, che introducono delle particolarissime sonorità all’interno del genere. Un compositore che fa largo utilizzo di sintetizzatori nei suoi brani è Arjen Lucassen, di cui spesso ho parlato in articoli precedenti.
Oltre alle immancabili chitarre, basso e batteria, spesso il prog fa utilizzo di strumenti atipici per il metal, come viola, violino, flauto, sassofono, pianoforte, clavicembalo, mandolino…
Un ottimo esempio di come il sassofono possa abbracciare il progerssive metal ci è fornito da Ihsahn, che nel suo album After ci delizia con dei fantastici assoli a opera di Jørgen Munkeby.

Tecnica e voce

Il progressive metal è un genere basato sulla sperimentazione. Sperimentazione di nuove sonorità, nuovi tempi, nuovi strumenti, nuove tecniche compositive.

Una delle caratteristiche di alcuni brani prog, è la complessità dei tempi. Le radio e la musica commerciale abituano l’orecchio a tempi molto semplici, come 2/4 e 4/4. Nel progressive metal, essendo appunto un genere sperimentale, si fa spesso utilizzo di tempi molto più complessi e difficili da seguire ma che nel complesso risultano molto più interessanti da ascoltare.

Per quanto riguarda la voce, il growl è uno degli aspetti del metal che è più difficile apprezzare, quando si è agli esordi. Generalmente è anche difficile da trovare nel progressive metal, essendo più caratteristico di generi come il death e il black metal, ma nonostante ciò c’è una band che è riuscita a fondere perfettamente il death metal con il progressive metal, facendo largo utilizzo del growl: gli Opeth. In particolare il cantante degli Opeth Mikael Åkerfeldt, è famoso per cantare sia le parti «lisce» che quelle in growl, ed è considerato una delle migliori voci growl.
Gli Opeth sono probabilmente la band ideale per chi vuole «imparare» ad ascoltare growl, essendo perfettamente miscelato con quello che può essere chiamato progressive death metal.

Un’altra caratteristica che contraddistingue il prog è la lunghezza degli assoli: assoli di chitarra, tastiera, sassofono, batteria e di ogni altro strumento, si presentano nella maggior parte dei brani. Anche gli assoli, come il growl, non sono facili da ascoltare le prime volte; addirittura potrebbero risultare troppo lunghi e noiosi se li si ascolta troppo superficialmente. Il prog è un genere abbastanza complesso che va ascoltato con attenzione, proprio come la musica classica! Infatti il paragone tra musica classica e progessive metal viene fatto spesso, proprio per i molti aspetti che hanno in comune; molte persone che ascoltano prog, spesso ascoltano anche musica classica.

I concept

I concept album, ossia gli album sviluppati su una trama o una storia ben precisa, non sono certo una prerogativa del progressive metal, ma le band prog che ne fanno uso sono davvero innumerevoli.
Tra gli esempi più noti vi sono senza dubbio gli Ayreon, il cui progetto musicale è interamente basato su una travolgente saga fantascientifica, di cui ogni album costituisce un elemento; i Pain of Salvation che pubblicano prevalentemente concept album, trattando temi che vanno dall’esistenziale-filosofico a questioni più concrete come la sessualità.
Gli stessi Dream Theater hanno pubblicato un concept, Metropolis Pt. 2: Scenes from a Memory, in cui viene narrata in modo teatrale l’intrigante storia di Nicholas e Victoria.

I concept album vanno generalmente ascoltati con il libretto originale, o almeno seguendo una trascrizione dei testi, sia per evitare di distrarsi mentre si ascolta, sia per poter seguire appieno la storia, dato che spesso i vari personaggi sono interpretati sempre dalla stessa voce.
Secondo il mio modesto parere, i concept album riescono a far provare delle emozioni che un normale album non è in grado di dare.

Come iniziare?

Da che punto bisogna partire per iniziare ad ascoltare progressive metal? La risposta a questa domanda credo sia molto suscettibile, dato che ogni persona dovrà scegliere un suo percorso preciso da seguire, in base ai propri gusti musicali. Ciò che posso sicuramente consigliare è di partire da album meno tecnici e più melodici, magari più semplici da ascoltare. Alcuni esempi sono: The Human Equation degli Ayreon, Metropolis Pt. 2: Scenes from a Memory dei Dream Theater, Remedy Lane dei Pain of Salvation, Emergent dei Gordian Knot, A Murder of Crows dei Dead Soul Tribe, e la lista potrebbe continuare ancora a lungo…

Un’altra band che consiglio fortemente a chi vuole iniziare ad ascoltare prog, sono i Pink Floyd. Anche se non è metal, è pur sempre progressive rock, che in un certo senso è la culla del progressive metal. Sono molte le band che richiamano sonorità nate con i Pink Floyd, i quali possono essere considerati come un’avanguardia del prog. Album fortemente consigliati sono The Dark Side of the Moon e Wish You Were Here

Attenzione! Un modo che suggerisco fortemente di adottare per ascoltare progressive metal è quello di riprodurre album interi, e non singole canzoni scaricate illegalmente o da YouTube, dato che ogni brano è spesso una parte costituente di un’opera più grande che può essere apprezzata solo se ascoltata nella sua interezza. Quindi, per quanto possa essere bello un brano preso singolarmente, è molto meglio ascoltarlo assieme agli altri brani dello stesso album.
Spesso inoltre è importante poter osservare la copertina che, come in un libro, completa anche emotivamente l’album grazie alle immagini rappresentate.

Strumenti utili

Per terminare questo articolo vorrei segnalare un paio di siti web che possono essere utili per la ricerca di nuovi album e nuove band:

• Metalstorm: è una community creata attorno ad un database abbastanza completo di musica metal. È molto utile per scoprire gli album più apprezzati dagli utenti, che possono votare artisti e album. Sono inoltre disponibili delle classifiche sui migliori album, filtrabili per genere musicale e anno di produzione.
• Encyclopaedia Metallum: è il database di musica metal più ampio che conosca. È possibile mostrare l’elenco di tutte le band progressive metal contenute nel database, sono qualche migliaio!
• Wikipedia: anche se può sembrare scontato, Wikipedia IT è davvero ben fornita di voci riguardanti band musicali. Spesso è in grado di fornirci informazioni anche molto interessanti che in genere è difficile trovare in giro.

Vorrei precisare che scaricare materiale non protetto da copyright tramite torrent, P2P e altri sistemi di file sharing NON COSTITUISCE REATO.

Per accedere a The Pirate Bay sono possibili diverse soluzioni, quella che propongo in questo articolo è quella di accedervi tramite il servizio offerto da Anonymouse:

http://anonymouse.org/cgi-bin/anon-www_de.cgi/http://thepiratebay.org/

Anonymouse è un servizio che permette di navigare in internet senza lasciare alcuna traccia delle nostre informazioni personali. Quando vi collegate a The Pirate Bay non siete voi realmente che effettuate l’accesso, ma è Anonymouse che lo fa per voi, restituendovi il contenuto della pagina.
La navigazione tramite Anonymouse può risultare più lenta della navigazione diretta, ma nel caso di download di piccoli file, come sono i .torrent, non è certo un problema.

Tramite un’applicazione della Microsoft, Keyboard Layout Creator, è possibile modificare il layout della tastiera per riempire tutti quei “buchi” a cui è soggetto il layout tradizionale, come ad esempio le accentate maiuscole. Vediamo come fare.

Scarichiamo e installiamo il software da questo indirizzo:
Keyboard Layout Creator
(Link alternativo)

Una volta aperto il programma, carichiamo il layout standard italiano da File -> Load Existing Keyboard… -> Italiano.
Cliccando sulle varie checkbox sulla sinistra possiamo vedere come varia il layout quando premiamo ctrl, alt, shift e le varie combinazioni. Clicchiamo su Show the Caps Lock e vediamo che le lettere accentate restano identiche a quando il Caps Lock è disattivato. Clicchiamo allora sulle lettere accentate e sostituiamole con le relative maiuscole, ossia: “À È Ì Ò Ù”.

Oltre a questa piccola modifica, possiamo personalizzare il layout della tastiera a nostro piacimento, aggiungendo simboli che utilizziamo spesso e che non sono presenti nel layout standard. Come potete vedere, infatti, i simboli associati al tasto AltGr sono appena cinque e abbiamo un’intera tastiera da poter personalizzare.

Una volta terminate le modifiche, per poter applicare il nuovo layout, dobbiamo compilarlo. Clicchiamo su Project -> Build DLL and Setup Package. Ci verrà chiesto di modificare il nome del layout se non lo abbiamo già fatto. Clicchiamo su Sì e inseriamo un nome per il layout. Clicchiamo su Ok, poi su No alla richiesta di vedere il file di log e infine su Sì alla richiesta di aprire la cartella in cui è stato creato il file di installazione.

All’interno della cartella che è stata creata, apriamo il file setup.exe e completiamo l’installazione. Una volta terminata il nuovo layout verrà installato sul nostro sistema e dovremo poi impostarlo come layout predefinito. Dal Pannello di Controllo apriamo la finestra di configurazione Paese e lingue, da cui selezioniamo la scheda Tastiere e lingue -> Cambia tastiere. Nella scheda Generale selezioniamo il nostro layout sotto la voce Lingua di input predefinita e infine clicchiamo su Ok.

A questo punto riavviamo il computer e la configurazione del nostro layout sarà finalmente completata.

Per i meno esperti che non vogliono scaricare il Keyboard Layout Creator per creare il proprio layout, possono scaricare l’installer già compilato da me di un layout con le sole maiuscole accentate modificate.
Download – Layout_Caps.zip

Una volta estratto ed installato dovete comunque impostarlo come layout predefinito per poterlo utilizzare.

Per chi fosse interessato ad un layout un po’ più complesso e personalizzato, potete utilizzare il seguente, che è molto pratico ed è stato realizzato da Davide:
Download – ITCustom.zip

La prima cosa che si può tentare di fare è cercare di riprodurre il video con un programma un po’ più flessibile, come ad esempio VLC, per poi salvarlo in un nuovo file. La lista di programmi che è possibile utilizzare per provare a riprodurre il video è pressoché interminabile, ma dopo averne provati 4-5 le speranze calano e si perde fiducia.

Il metodo che intendo spiegare in questo articolo non è proprio semplicissimo, specie per chi non ha mai avuto a che fare con l’hex editing, ma cercherò di spiegare tutti i passaggi in modo quanto più dattagliato è possibile.

Premetto che non sono un esperto di editing video e la soluzione a cui sono giunto deriva da numerose ricerche su google e sui vari forum dedicati all’argomento. Inoltre in questa guida utilizzo software per Windows, ma il procedimento può essere seguito con software equivalenti su GNU/Linux.

Vediamo in breve quali sono le operazioni da effettuare per ripristinare un video:

1. Recupero: qualora il video fosse stato cancellato, la prima cosa da fare è cercare di recuperarlo per poterlo riparare
2. Riparazione: la riparazione che tenteremo di effettuare consisterà nel sostiture alcune righe del file danneggiato con quelle di un file funzionante dello stesso tipo
3. Salvataggio: una volta riparato il file, ne salveremo una versione riproducibile in un nuovo file MP4

1. Recupero

Se il nostro problema deriva da una cancellazione accidentale (o non!) del video, la prima cosa da fare è tentare di recuperarlo. È importante notare che quando un file viene “cancellato” dal dispositivo, nella maggior parte dei casi non viene realmente eliminato dalla memoria, ma viene “nascosto” rendendo lo spazio da lui occupato disponibile per altri file. Se quindi dopo la cancellazione la memoria non è stata più utilizzata, le probabilità di ritrovare il file integro sono abbastanza elevate.

Il programma che ho utilizzato con Windows è WinHex, disponibile anche in versione free. Su GNU/Linux è disponibile una valida alternativa che è PhotoRec.
Da Strumenti -> Apri unità disco selezioniamo la nostra memoria nel gruppo Unità logiche. Se non dovesse aprirsi la finestra che permette di esplorare le cartelle, visualizziamola tramite Visualizza -> Mostra -> Esplora cartella. Tramite questa finestra possiamo accedere alla cartella contenente il file cancellato, che è possibile recuperare semplicemente tramite Click destro sul file -> Recupera/Copia. Se il file dovesse essere contrassegnato da un’icona con una X e dimensioni di pohi kB, il suo recupero potrebbe diventare molto più complicato. Lo stesso vale se questo non dovesse essere affatto presente nella lista di file. In questo caso WinHex mette a disposizione degli strumenti, accessibili tramite Strumenti -> Utilità disco sui quali però non mi soffermerò.

2. Riparazione

Veniamo ora alla parte più interessante di questa guida. In questa fase avremo bisogno di un editor esadecimale; potete utilizzare ancora WinHex se siete su Windows, oppure una qualsiasi alternativa come Shed per sistemi GNU/Linux.
Prima di dirvi come procedere è necessario capire innanzitutto come è strutturato un file MP4: una spiegazione dettagliata la potete trovare QUI; in breve esso è costituito da una serie di atom, che sono una specie di tag contenenti informazioni sui video. Ogni atom è costituito da 8 byte (caratteri): 4 byte per la sua dimensione (in giallo, nella foto) e altri 4 per il nome (in azzurro).

La riparazione che tenteremo di effettuare consiste nel copiare l’atom di nome esds da un filmato funzionante a quello danneggiato.
Apriamo con un editor esadecimale un filmato girato con lo stesso dispositivo del video danneggiato e cerchiamo la stringa esds. Dovrebbe essercene una sola, preceduta dall’atom mp4v e seguita dall’atom mdat.
Selezioniamo tutto l’atom esds, partendo da 4 byte prima del nome, fino a 4 byte prima di mdat, come indicato nella figura:

Questa stringa va copiata tra l’atom ftyp e l’atom esds, nella prima riga del file danneggiato. Ricordate sempre che l’atom inizia con i 4 byte sulle dimensioni, seguiti dai 4 byte del nome, quindi la stringa va incollata giusto 4 caratteri prima della stringa “esds”, come indicato in figura:

A questo punto siamo pronti per la fase finale, il salvataggio del video in una versione riproducibile.

3. Salvataggio

Per salvare il file in una versione riproducibile utilizzeremo MP4Creator, un software open source che permette di aprire il bytestream e salvarlo come filmato MP4 riproducibile.
Per prima cosa rinominiamo il file video danneggiato da .mp4 a .mp4v, altrimenti il software non riconosce l’estensione. Collochiamo MP4Creator e il video da riparare nella stessa directory, ed eseguiamo il seguente comando:

mp4creator --create=fdanneggiato.mp4v --rate=24 --verbose video.mp4

Sostituendo ovviamente fdanneggiato e rate con i parametri del nostro video. In realtà MP4Creator supporta l’opzione –variable-frame-rate, ma con me non ha funzionato, su nessuno dei due pc con cui ho provato.
Se tutto è andato a buon fine, il nuovo file video.mp4 dovrebbe essere visualizzabile correttamente da qualsiasi player video.

L’unico problema di questo sistema è che non riesce a recuperare l’audio dei filmati. Ripeto, non essendo un esperto di editing video non so di preciso a cosa sia dovuto il problema, ma sono quasi sicuro se si possa recuperare anche quello.

In conclusione, ho testato questo procedimento sia con un filmato la cui registrazione è stata bruscamente interrotta, sia con un filmato che era stato cancellato da un cellulare (Nokia N82) e in entrambi i casi sono riuscito a recuperare il video con successo.

Se si prova ad accedere al vecchio indirizzo del sito, viene mostrato un messaggio che informa sull’esistenza della nuova versione, accessibile tramite questo indirizzo:
www.segrepass.unina.it

Già dalla prima schermata si nota, oltre alla grafica estremamente migliorata, il cambio del sistema di login. Prima infatti si poteva accedere al servizio solo tramite matricola e pin (con la matricola case sensitive che faceva differenza tra N123 e n123), ora è possibile utilizzare le varie combinazioni matricola/pin, codice fiscale/pin, username/password.

La prima enorme differenza rispetto alla prima versione che devo segnalare, è la perfetta fruibilità del sito con Firefox. Non ho ancora avuto il tempo di provare il servizio con altri browser, ma dato che l’accessibilità era proprio il primo problema del vecchio Esis, immagino (spero) che abbiano lavorato molto su questo aspetto. (Basti ricordare che la precedente versione si apriva in un pop-up e tutti i browser bloccano di default l’apertura di pop-up!)

Una rapida occhiata al codice HTML delle pagine mostra purtroppo che questo non rispetta gli standard del W3C (l’ente che si occupa dell’accessibilità e degli standard dei siti web), infatti prima della dichiarazione del doctype vi sono una ventina di caratteri “a capo” che non permettono la validazione del W3C Validator.

Una volta effettuato l’accesso è possibile notare la nuova struttura dei menù, che è davvero molto chiara e intuitiva.
Nel menù Dati Carriera sono disponibili una serie di funzioni di riepilogo sui dati universitari molto utili, come il riepilogo delle spese universitarie e quello sugli esami e sui crediti, che calcola automaticamente diversi tipi di media (aritmetica, ponderata, in trentesimi e in centodecimi).

Per quanto riguarda la prenotazione degli esami non posso ancora testarla, perché i miei professori non hanno ancora pubblicato le date d’esame sul sito, quindi non posso effettuare prenotazioni.
Da quanto c’è scritto, il sistema dovrebbe controllare automaticamente le propedeuticità degli esami permettendo di prenotare solo gli esami che è possibile sostenere.

Inoltre nel menù è presente una nuova voce: Certificati. Purtroppo non è possibile stampare dei veri e propri certificati tramite il proprio computer, infatti in questa sezione viene visualizzato il messaggio: “E’ possibile stampare i certificati che visualizzi in questa sezione solo dalle postazioni situate nelle aule multimediali.“. Non so se questa scelta sia stata fatta per motivi legali o altro, ma è comunque possibile stampare gli stessi documenti sottoforma di autocertificazioni.

Nel complesso, il servizio è stato notevolmente migliorato sotto molti aspetti. Prima del verdetto finale, però, dobbiamo aspettare la prossima sessione d’esami, quando i server verranno stressati dalle migliaia di richieste di prenotazione esame e ci sarà un’altissima probabilità di malfunzionamenti.

- normalità in quanto salute, opposta a malattia;

- normalità in quanto media statistica;

- normalità in quanto ideale, utopia da realizzare a cui avvicinarsi;

- normalità in quanto processo dinamico, capacità di tornare ad un certo equilibrio.

Confusione? Cerchiamo di schiarire le idee su cos’è allora la patologia ( “Psicologia clinica” di Hansell J. e Damour L. )

- ricerca di aiuto ( rientrano in questa categoria anche le persone sotto una naturale condizione di stress );

- irrazionalità/pericolosità ( ma l’innamoramento non è irrazionale? );

- devianza ( Einstein, Gandhi, Shakespeare, Micheal Jordan… );

- distress emozionale  ( ci sono disturbi di personalità, antisociale per esempio, in cui raramente si riporta distress emozionale e poi ci sono comportamenti naturali, come l’elaborazione del lutto, che rientrano in questa categoria );

- danno significativo ( diversi danni alle funzioni psicologiche sono causati da lesioni o traumi fisici e non psichici ).

Mezza provocazione: non sarebbe più etimologicamente corretto l’uso della parola “natura” dell’abuso di “normale”?