Robitex's Blog

Ideas in the web

Spettri sismici – Parte 2


Un codice più flessibile

Continuiamo il perfezionamento del codice che avevamo scritto in precedenza per il disegno degli spettri elastici di progetto secondo il capitolo 3 delle nuove norme sulle costruzioni (D.M. 14/01/2008), dipendente dai tre parametri base a_g/g, F_0, T_C^* e relativamente agli stati limite di operatività SLO, di danno SLD, di salvaguardiadella vita SLV e di collasso SLC.

In Asymptote, il software che useremo per svolgere i calcoli e plottare i grafici, esiste la possibilità di creare nuovi tipi di dato che incorporano dati e funzioni, ovvero l’invenzione della programmazione ad oggetti.

Questa possibilità è offerta da struct, il costrutto che assomiglia a quello del C++, che ci permetterà di rappresentare le Categorie di sottosuolo e le categorie topografiche del sito.

E cominciando da quest’ultima. Serve un oggetto che chiameremo TopoCat che memorizzi il valore del coefficiente topografico e che lo restituisca per mezzo di una funzione:

// oggetto per le categorie topografiche
struct TopoCat {
   private real st;
   void operator init(real st){
      this.st = st;
   }
   real St(){
      return this.st;
   }
}

Abbiamo dichiarato come privato il campo st così che solo le funzioni pubbliche ne costituiscano l’interfaccia, ed inserito lo speciale operatore init che definisce il cosidetto costruttore, con cui l’utente creerà nuove istanze dell’oggetto. In questo caso il costruttore inizializza il campo interno accessibile con il riferimento this in dot notation.

Per instanziare un oggetto per ciascuna categoria topografica scriveremo così, creando i quattro tipi classici previsti dalla tabella 3.2.VI della norma:

// categorie topografiche classiche
TopoCat T1 = TopoCat(1.0);
TopoCat T2 = TopoCat(1.2);
TopoCat T3 = TopoCat(1.2);
TopoCat T4 = TopoCat(1.4);

Anche per le categorie di sottosuolo creiamo un oggetto apposito che viene instanziato con i coefficienti della tabella 3.2.V per fornire, sottoforma di funzioni naturalmente, i valori di Ss e Cc.

Da notare come il codice gestisce l’espressione di Ss: invece di riferirsi a campi interni dell’oggetto, i valori di ag/g e F0 devono semplicemente essere passati alle funzioni pubbliche (dette anche ‘metodi’ nel gergo della Object Oriented Programming).
Credo anche che fare la stessa cosa con un foglio di calcolo non sia così immediato.

// Categoria di sottosuolo
struct SoilCat {
   private real minSs;
   private real maxSs;
   private real k1;
   private real k2;
   private real h1;
   private real h2;

   // constructor
   void operator init(real mn, real mx, real k1, real k2, real h1, real h2){
      this.minSs = mn;
      this.maxSs = mx;
      this.k1 = k1;
      this.k2 = k2;
      this.h1 = h1;
      this.h2 = h2;
   }

   real Ss(real agg, real f0){// return the Ss value
      private real s;
      s = this.k1 - this.k2 * f0 * agg;
      if ( s < this.minSs ) {
         s = this.minSs;
      }
      if ( s > this.maxSs ) {
         s = this.maxSs;
      }
      return s;
   }
   
   real Cc(real tc){// return the Cc value
      return this.h1 * tc^this.h2;
   }
}

//
// istanziamento oggetti categorie sottosuolo (Tab. 3.2.V)
//
SoilCat A = SoilCat( 1.00 , 1.00 , 1.00 ,  0.00 , 1.00 ,  0.00);
SoilCat B = SoilCat( 1.00 , 1.20 , 1.40 , -0.40 , 1.10 , -0.20);
SoilCat C = SoilCat( 1.00 , 1.50 , 1.70 , -0.60 , 1.05 , -0.33);
SoilCat D = SoilCat( 0.90 , 1.80 , 2.40 , -1.50 , 1.25 , -0.50);
SoilCat E = SoilCat( 1.00 , 1.60 , 2.00 , -1.10 , 1.15 , -0.40);

Bene, notate come ovunque nel codice ci siano le dichiarazioni di tipo (il tipo corrispondente viene premesso al nome di ogni variabile), come richiede il linguaggio fortemente tipizzato di Asymptote.

Il codice finora scritto consente di rappresentare due diverse caratteristiche del sito. E’ naturale inglobare le due categorie in un ulteriore nuovo oggetto per rappresentare unitariamente il sito ed esporre i metodi per il disegno degli spettri.

Chiamiamo questo oggetto Spettro:

// Struct contenenti i parametri sismici del
// sito per lo Stati Limite considerato
// e funzioni grafiche e numeriche
//
// agrel = ag/g  ,  f0= F0  , tcstar = TC*
//
// q = fattore di struttura
//
struct Spettro {
   private real agrel;
   private real f0;
   private real tcstar;
  
   private real q;
   
   private real eta;
   
   private real smax;
   
   // periodi d'intervallo
   private real tb;
   private real tc;
   private real td;
   
   // ecco quì le caratteristiche del sito
   // rappresentate come campi privati
   private SoilCat soilC;
   private TopoCat topoC;
   
  // array dei punti notevoli
   pair[] keydot;
   
   // funzioni di definizione per intervalli dello spettro
   real s1(real T) {
      return  this.smax * ((T/this.tb) + (1 - T/this.tb)/(this.eta * this.f0));
    }

   real s3(real T){
      return this.smax * this.tc / T;
   }

   real s4(real T){
      return this.smax * (this.tc * this.td ) / T^2;
   }
   
  // costruttore
   void operator init(SoilCat s, TopoCat t, real q, real ag, real f0, real tc){
      this.soilC = s;
      this.topoC = t;
      this.q = q;
      this.agrel = ag;
      this.f0 = f0;
      this.tcstar = tc;

      this.eta = 1/q;

      this.tc = s.Cc(tc)*tc;
      this.tb = this.tc/3;
      this.td = 4.0 * ag + 1.60;

      this.smax = ag * s.Ss(ag,f0) * t.St() * (1/q) * f0;

      this.keydot = new pair[]{
        (      0 , this.s1(0)),
        (this.tb , this.smax),
        (this.tc , this.smax),
        (this.td , this.s4(this.td))
      };
   }
   guide plot(real xmax){
     return graph(this.s1 , 0 , this.tb)                   &
            (this.tb , this.smax) -- (this.tc , this.smax) &
            graph(this.s3 , this.tc , this.td)             &
            graph(this.s4 , this.td , xmax);
   }
}

Un commento anche per questo ultimo codice: la struct inizia con la dichiarazione dei campi privati e prosegue con quella delle funzioni matematiche dei rami dello spettro sismico ricavate dalla norma. La loro definizione deve precedere l’operatore init, poiché il costruttore ne fa uso per inizializzare le coordinate dei punti estremi dei rami dello spettro ai periodi Tb, Tc, e Td, salvandoli in un array chiamato keydot. Infine, il metodo plot che restituisce l’intero “percorso” del grafico.

L’oggetto non memorizza ulteriori metodi per facilitare il disegno dei grafici perché così facendo si lascia totale libertà di configurazione dei dettagli. In fondo la curva dello spettro è un oggetto indipendente dalla “tela” sulla quale verrà plottata.

Il codice “utente”

Ecco come può essere utilizzato il codice appena scritto. Consideriamo un sito su un terreno tipo B in pendio (T2). I quattro spettri elastici (q=1) con i vari parametri ag/g, F0 e Tc* saranno per esempio:

//
// un "oggetto struct" per singolo spettro
// istanziati con i dati sismici del sito
//
Spettro slo = Spettro(B, T2, 1.00, 0.04873, 2.462, 0.239);
Spettro sld = Spettro(B, T2, 1.00, 0.06107, 2.484, 0.251);
Spettro slv = Spettro(B, T2, 1.00, 0.15182, 2.402, 0.290);
Spettro slc = Spettro(B, T2, 1.00, 0.19475, 2.379, 0.298);

Il risultato

Non rimane che eseguire i plottaggi con il seguente codice, per ottenere in formato PDF il grafico completo pronto per essere inserito in relazione:

//
// plot degli spettri
//
size(16cm, 10cm, IgnoreAspect);
xlimits( 0 , 4.32);
ylimits( 0 , 0.72);

xaxis("$T$ (s)" ,
      BottomTop(),
      LeftTicks( Label(fontsize(8)) ,
               ptick=lightgray ,
               pTick=gray ,
               extend = true
               )
      );

yaxis("$S_{e}/g$" ,
      LeftRight(),
      RightTicks( Label(fontsize(8)),
                  pTick=lightgray,
                  extend = true
               )
      );

// plottaggio spettri (l'ordine è dall'alto verso il basso
// per la corrispondenza con la legenda
draw(slc.plot(4.2), red    + 1.80, "SLC");
draw(slv.plot(4.2), blue   + 1.80, "SLV");
draw(sld.plot(4.2), orange + 1.80, "SLD");
draw(slo.plot(4.2), green  + 1.80, "SLO");

// disegno dei punti notevoli
pen punto = linewidth(1.28bp);
dot(slc.keydot, punto);
dot(slv.keydot, punto);
dot(sld.keydot, punto);
dot(slo.keydot, punto);

// legenda
add(legend(), (3.1 , 0.60) , UnFill );
Spettri Sismici, fare click per scaricare il PDF

Spettri Sismici, fare click per scaricare il PDF

Cosa ci aspetta il futuro

Potremo aggiungere al grafico alcune informazioni di input per dare un tocco di professionalità, e pensare ad un modulo che calcoli i parametri ag/g, F0, Tc* del sito inserendone le coordinate geografiche. Chissà staremo a vedere.
Ciao

Lascia un commento

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...

%d blogger cliccano Mi Piace per questo: