Approssimazione ad elementi finiti di problemi elittici bidimensionali con il metodo di decomposizione dei domini di Schwarz

Transcript

1 POLITECNICO DI MILANO Corso di Studi in Ingegneria Matematica Programmazione Avanzata per il Calcolo Scientifico e Analisi Numerica delle EDP II Approssimazione ad elementi finiti di problemi elittici bidimensionali con il metodo di decomposizione dei domini di Schwarz Mazzoleni Erik Pischedda Marco Andrea Matr Matr ANNO ACCADEMICO

2 Sommario Questo progetto tratta l implementazione di una libreria ad elementi finiti lineari per la risoluzione di problemi ellittici su un dominio bidimensionale. In particolare, per la risoluzione del sistema lineare associato al problema, si utilizza un metodo iterativo con diversi precondizionatori costruiti con la tecnica di decomposizione dei domini. Viene infatti interpretato a livello algebrico il metodo di Schwarz additivo ad un livello e a due livelli, mantenedo una sovrapposizione minima tra i diversi sottodomini. La decomposizione dei domini permette di scomporre il problema iniziale in tanti sottoproblemi più semplici da risolvere. Per questo motivo essa ha rilevanti applicazioni in campo numerico per una risoluzione più efficiente e veloce del problema iniziale, anche in un ottica parallela. Nei capitoli che seguiranno si darà una descizione dei passaggi che intercorrono tra la teoria e l implementazione del metodo di Schwarz additivo. In particolare, nel primo capitolo verrà richiamata la teoria della decomposizione dei domini associata alla risoluzione di un problema ellittico alle derivate parziali. Nel secondo capitolo verrà discussa la struttura, l implementazione e la logica della libreria di calcolo costruita. Nel terzo capitolo si effettueranno delle analisi e dei confronti numerici tra i diversi precondizionatori impiegati.

3 Indice 1 Il metodo di Schwarz Approssimazione di un EDP con un metodo di decomposizione dei domini Il metodo di Schwarz ad un livello Schwarz a due livelli Descrizione del Codice Schema generale del codice Dettagli implementativi Le classi Point2D e Triangle La classe Mesh Le classi Template La classe Quadrature La classe FE Matrix Il file assembla.hpp La classe Problem Il file domain.hpp Le classi per i precondizionatori di Schwarz Il file iterative solver.hpp Le funzioni per il calcolo dell errore Il post processing dei dati Il file di prova main.cpp Analisi e Risultati Validazione della libreria DDFEM Analisi della stime di convergenza per i diversi precondizionatori Analisi di Schwarz additivo ad un livello Analisi di Schwarz a due livelli di tipo interpolativo Analisi di Schwarz a due livelli di tipo aggregativo Confronto tra i precondizionatori a due livelli Conclusioni 43 A L utilizzo dei programmi Triangle e Metis 44 1

4 Capitolo 1 Il metodo di Schwarz 1.1 Approssimazione di un EDP con un metodo di decomposizione dei domini Un metodo per risolvere un problema alle derivate parziali è la decomposizione dei domini. Questa tecnica consiste nel suddividere il dominio di partenza in tanti sottodomini ed in seguito collocare il problema su ciascun sottodominio. Così facendo la complessità del problema iniziale viene distribuita nella risoluzione di un numero maggiore di problemi più semplici, secondo la logica divide et impera. L utilizzo della decomposizione dei domini permette anche la semplificazione di geometrie iniziali più articolate costruendo dei sottodomini dalla forma più elementare. Ci sono due principali modi di partizionamento del dominio iniziale, ovvero l utilizzo o meno di una sovrapposizione (overlap) fra le sottoregioni che si vogliono creare (Figura 1.1). I metodi che si basano sulla separazione netta fra i sottodomini vengono detti di Schur, mentre quelli che si sviluppano a partire da sottodomini con overlap vengono detti di Schwarz[6]. Consideriamo un dominio Ω R 2 regolare e su di esso si collochi il seguente problema alle Figura 1.1: Sepazione in due domini senza overlap a sinistra e con overlap a destra. derivate parziali: Lu = f in Ω u = g su Ω dove L è un generico operatore ellittico ed f e g sono funzioni assegnate. Si vuole cercare una soluzione u per questo problema differenziale utilizzando la tecnica di decomposizione dei domini. Scegliamo di creare delle sottoregioni con sovrapposizione e a questo scopo generiamo due sottodomini Ω 1 e Ω 2 del dominio iniziale Ω. Chiamiamo con Γ 1 = Ω 1 \ Ω e con Γ 2 = Ω 2 \ Ω. Possiamo ora formulare il metodo iterativo di Schwarz che, data una soluzione iniziale (1.1) 2

5 û (0) 2, per k > 0, chiede di risolvere: Lû (k+1) 1 = f in Ω 1 û (k+1) 1 = û (k) 2 su Γ 1 û (k+1) 1 = g su Ω 1 \Γ 1 Lû (k+1) 2 = f in Ω 2 û (k+1) 2 = û (k+1) 1 û (k) 1 su Γ 2 û (k+1) 2 = g su Ω 2 \Γ 2 La procedura illustrata genera due successioni di funzioni û (k) 1 e û (k) 2, per ogni k, su ciascuno dei domini di appartenenza, le quali convergono alla soluzione u esatta del problema (1.1) ristretta alle rispettive sottoregioni. Come si nota dalla seconda equazione del sistema (1.3) è possibile operare una scelta su quale tipo di funzione utilizzare come dato al bordo nella risoluzione del problema sul dominio Ω 2. Si può infatti preferire come dato al bordo la soluzione û 1 calcolata al passo corrente oppure quella del passo precedente. Nel primo caso il metodo scelto si dirà di Schwarz moltiplicativo o sequenziale, nel secondo caso si parlerà invece di Schwarz additivo o parallelo. L algoritmo di Schwarz parallelo sembra essere quello più interessante in quanto, utilizzando la soluzione sul primo dominio al passo precedente, consente di risolvere i problemi (1.2) e (1.3) contemporaneamente, con grande risparmio di tempo. È possibile affontare l analisi dei metodi di Schwarz sia da un punto di vista variazionale che algebrico. Il caso variazionale è essenziale per effettuare un analisi di convergenza del metodo e fornisce dei suggerimenti per la formulazione dell approccio algebrico. Quest ultimo procedimento, invece, si occupa di fornire dei precondizionatori per la risoluzione numerica del sistema lineare generato dalla discretizzazione ad elementi finiti del problema differenziale considerato. A questo scopo riformuliamo il problema (1.1) esplicitando l operatore L e introducendo le ipotesi necessarie: div(α u) + b u + σu = f in Ω (1.4) u = g su Ω con Ω R 2, f L 2 (Ω) e g H 1/2 ( Ω). Inoltre i coefficienti α, σ e b sono funzioni (o costanti) assegnate: α, σ L (Ω), con α(x) > α 0 > 0 e σ(x) 0. Inoltre b [L (Ω)] 2, con div(b) L 2 (Ω). Per trovare una soluzione u adeguata, consideriamo la formulazione debole del problema (1.4) e scegliamo uno spazio di funzioni test V = H0(Ω). 1 Moltiplicando l equazione (1.4) per una funzione test v V ed integrando sul dominio Ω, otteniamo: div(α u)v dω + vb u dω + σuv dω = fv dω. Ω Ω Integrando per parti il primo termine dell equazione integrale ottenuta e utilizzando contemporaneamente il fatto che la funzione test v è nulla al bordo, possiamo riformulare il problema nel seguente modo: trovare u V g : α u v dω+ vb u dω+ σuv dω = fv dω v V (1.5) Ω Ω Ω Ω 3 Ω Ω (1.2) (1.3)

6 dove V g = {v H 1 (Ω) : v Ω = g}. La formulazione (1.5) opera con due spazi differenti per quanto riguarda la soluzione u V g e le funzioni test v V. Per cercare la soluzione nello stesso spazio delle funzioni test operiamo con un rilevamento del dato al bordo. Per fare questo supponiamo di conoscere una funzione R g, detta rilevamento, tale che: R g H 1 (Ω), R g Ω = g. A questo punto poniamo ũ = u R g in modo tale che ũ V e che risulti quindi nulla al bordo. Se ora definiamo a(ũ, v) = α ũ v dω + vb ũ dω + σũv dω e Ω F (v) = Ω Ω fv dω a(r g, v) possiamo riscrivere la (1.5) nella seguente forma compatta: trovare ũ V : a(ũ, v) = F (v) v V. (1.6) In questo modo la soluzione ũ e la funzione test v sono nello stesso spazio V. Grazie alle ipotesi fatte sui coefficienti, la forma bilineare a(u, v) è continua e coerciva. Essendo inoltre il funzionale F (v) lineare e continuo, possiamo applicare il Lemma di Lax-Milgram che ci garantisce l unicità della soluzione e la sua dipendenza continua dai dati iniziali. Introduciamo ora la formulazione alla Galerkin - elementi finiti del problema in esame, a partire dalla formulazione (1.6). Consideriamo uno spazio finito dimensionale V h V, dipendente da una paramentro positivo h, e sia N h la sua dimensione. In questo contesto il problema di Galerkin diviene: trovare u h V h : a(u h, v h ) = F (v h ) v h V h (1.7) dove u h è un approssimazione della soluzione ũ in (1.6). Proiettando il problema su un base {ϕ j, j = 1, 2,..., N h } dello spazio V h si ha: a(u h, ϕ i ) = F (ϕ i ) i = 1, 2,..., N h. (1.8) Ogni elemento dello spazio V h può essere espresso come combinazione lineare degli elementi della base appena introdotta. Quindi anche la soluzione incognita u h è rappresentata da un unica sequenza di coefficienti incogniti u j, con j = 1, 2,..., N h, in modo tale che: N h u h (x) = u j ϕ j (x). (1.9) j=1 Sostituendo l espressione ricavata per u h nell equazione (1.8) otteniamo il sistema di equazioni: N h j=1 u j a(ϕ j, ϕ i ) = F (ϕ i ) i = 1, 2,..., N h, che può essere scritto in modo sintetico nel sistema lineare algebrico: Ω Au = f (1.10) con a ij (1.9). = a(ϕ j, ϕ i ), f i = F (ϕ i ) e u il vettore dei coefficienti incogniti della decomposizione 4

7 La matrice A eredita le proprietà della forma bilineare a(u, v), in particolare essa è definita positiva per l ipotesi di coercività ed è simmetrica per alcune scelte dei coefficienti del problema (1.4). Scegliendo opportunamente delle funzioni di base che abbiano un piccolo supporto, si produce una matrice sparsa, ovvero con un numero elevato di zeri al suo interno e di conseguenza più semplice da risolvere rispetto ad una piena. Consideriamo una triangolazione τ h del dominio Ω R 2 e poniamo h K = max x,y K x y K τ h. Definiamo inoltre h = max K τh h K ; esso è il nostro parametro di riferimento che è stato introdotto in maniera generale in (1.7) e che stabilisce il legame tra la griglia e la dimensione N h di V h. Scegliamo lo spazio dei polinomi lineari a tratti come spazio V h nella formulazione debole alla Galerkin, ovvero poniamo: V h = {v h C 0 (Ω) : v h K P 1, K τ h, v h Ω = 0}. In particolare scegliamo una base lagrangiana per questo spazio in modo tale da ottenere una matrice A sparsa. Con questo tipo di scelta la generica funzione di base ϕ j ha una forma piramidale ed assume valore unitario nel nodo centrale del suo supporto, come mostrato in Figura 1.2. La ricerca della soluzione diventa la determinazione del valore della funzione incognita nei nodi interni della griglia, i quali rappresentano gli N h gradi di libertà del problema (1.7). Figura 1.2: Esempio di funzione di base lineare e del suo supporto. 1.2 Il metodo di Schwarz ad un livello Vogliamo ora utilizzare il metodo di Schwarz per risolvere il sistema (1.10). Supponiamo quindi di avere due sottodomini Ω 1 e Ω 2, che abbiano una certa zona di sovrapposizione, e chiamiamo con n 1 ed n 2 il numero dei nodi interni dei rispettivi domini. In generale accade che n1 + n2 N h, per la presenza di nodi in comune tra i domini Ω 1 e Ω 2. La struttura della matrice A dipende dalla numerazione dei nodi scelta. Per ottenere anche a livello matriciale una suddivisione in due sottodomini è necessario rinumerare i nodi in modo tale che i primi n 1 nodi appartengano al primo dominio, mentre gli ultimi n 2 nodi appartengano al secondo. La situazione che si presenta è quella mostrata in Figura 1.3 nella quale A 1 e A 2 corrispondono alle matrici ad elementi finiti costruite sui nodi interni dei due sottodomini. Se si considera un overlap minimo, ovvero una sovrapposizione tra i domini che coinvolga sempre una singola striscia di elementi, la matrice A assume una struttura a blocchi. In questo caso si ha N h = n1 + n2 e di conseguenza non si riscontrano nodi interni in comune tra i due domini, a differenza di quanto visto in Figura 1.3. La matrice A può essere dunque rappresentata graficamente nel seguente modo: A 1 A 12 A =. (1.11) A 21 A 2 5

8 Figura 1.3: Le due sottomatrici A 1 e A 2. Le matrici A 12 e A 21 sono le responsabili delle interconnessioni tra un dominio e l altro; infatti esse contengono le informazioni delle funzioni di base associate ai nodi che sono contemporaneamente di bordo per un dominio ed interni per l altro dominio. La decomposizione (1.11) può essere estesa in modo naturale al caso di M sottodomini, ottenendo la seguente struttura: A 11 A A 1M A 21 A A 2M A =. (1.12) A M A MM Tornando al caso di due sottodomini e considerando la decomposizione (1.11), è possibile estrarre facilmente la matrici A 1 e A 2 dalla matrice A utilizzando delle matrici rettangolari così definite: R1 T = R N h n 1, R2 T = R N h n 2. (1.13) Grazie a queste definizioni possiamo scrivere che A 1 = R 1 AR1 T R n 1 n 1 e A 2 = R 2 AR2 T R n 2 n 2. La matrice R i è chiamata operatore di restrizione poichè trasporta vettori definiti su R N h in vettori di R n i. Operazione contraria viene effettuata dalla matrice Ri T, detta di prolungamento. A partire dallo schema generico di Schwarz, illustrato nelle (1.2) e (1.3), è possible ricavare un metodo iterativo algebrico per la risoluzione del sistema (1.10). A seconda della scelta sulle condizioni al bordo nell equazione (1.3), otteniamo per Schwarz moltiplivativo: mentre per Schwarz additivo si ha: u k+1 = u k + (Q 1 + Q 2 Q 2 AQ 1 )(f Au k ), (1.14) u k+1 = u k + (Q 1 + Q 2 )(f Au k ), (1.15) dove in entrambi i metodi Q i = R T i A 1 i R i, per i = 1, 2. La (1.14) e la (1.15) sono dei metodi di Richardson per la risoluzione del sistema lineare (1.10). La natura dei precondizionatori utilizzati fa capire l uso degli aggettivi moltiplicativo e additivo per distinguere i due algoritmi. La nostra attenzione si concentrerà sul metodo di Schwarz additivo, per la sua proprietà di essere facilmente applicabile al calcolo parallelo. 6

9 Da principio estendiamo la (1.15) al caso di più sottodomini. Chiamato con M 2 il numero dei domini considerati, otteniamo lo schema: Indichiamo poi con M u k+1 = u k + ( Q i )(f Au k ). (1.16) i=1 P 1 as = M Q i (1.17) il precondizionatore di Schwarz additivo ottenuto dalla (1.16). Se implementassimo lo schema di Richardson precisamente come è scritto nella (1.16), incorreremmo in una serie di svantaggi. In primo luogo bisogna garantire la convergenza del metodo, utilizzando un opportuno paramentro di rilassamento α: in questo frangente gli autovalori della matrice A precondizionata svolgono un ruolo decisivo. In secondo luogo la velocità di convergenza del metodo è molto bassa rispetto ad altri metodi numerici. A questi incovenienti è possibile porre rimedio estrapolando il precondizionatore P as dal contesto della (1.16) e applicandolo ad un metodo più rapido come il gradiente coniugato precondizionato o il Bi-CGSTAB. Quest ultimo metodo è quello da noi utilizzato per la risoluzione del sistema lineare (1.10). Il Bi-CGSTAB ha il vantaggio di risolvere sistemi lineari con matrici non simmetriche consentendo di trattare casi più generali[4]. La struttura del precondizionatore di Schwarz additivo, definito in (1.17), permette di gestire la risoluzione del sistema lineare in parallelo. A tal fine predisponiamo un numero M (pari al numero di domini) di macchine che operano in parallelo. Ciascuna di esse conterrà il proprio precondizionatore Q i, ovvero avrà i propri operatori R i, e sarà in grado di risolvere un sistema lineare di matrice A i ricavata dalla decomposizione (1.12). Ogni volta che, nello schema numerico utilizzato, è necessario applicare il precondizionatore P as al residuo f Au k, sarà sufficiente affidare quest ultimo alle M macchine predisposte che si preoccuperanno di modificare soltanto la parte del residuo di loro competenza. Un importante vantaggio della decomposizione dei domini è che non si deve mai risolvere direttamente un sistema lineare della dimensione della matrice A, ma si opera con la soluzione in parallelo di M sistemi più piccoli. Per questo motivo sembra risultare conveniente l aumentare il più possibile il numero dei domini. In realtà questo tipo di approccio porta ad un aumento della complessità globale del problema che diventa più difficle da risolvere. Infatti l utilizzo del precondizionatore P as comporta l impiego di risolutori locali che, al crescere del numero dei domini, riescono a comunicare solo con i propri vicini e risentono solo dopo molto tempo dell informazione portata da un dominio lontano. Questo fenomeno è comprovato dall andamento del numero di condizionamento della matrice precondizionata Pas 1 A. Definendo con δ la misura della sovrapposizione fra i domini, H = max i=1...m {diam(ω i )}, dove diam(ω i ) = max x,y Ωi x y, e con C una costante indipendente da h,h e δ, è possibile dimostrare la seguente stima: i=1 K(P 1 as A) C 1 δh. (1.18) Nel caso di una sovrapposizione tra i domini che coinvolga una singola striscia di elementi si ha che δ = h. Di conseguenza infittire la griglia, diminuendo h, o aumentare il numero dei sottodomini, diminuendo H, rallenta la risoluzione del problema. In questa situazione si dice che il precondizionatore P as non è scalabile, ovvero il numero di conzionamento della matrice Pas 1 A dipende dal numero dei sottodomini. La ricerca di un precondizionatore che sia scalabile diventa, in questo contesto, l obiettivo ottimale. 7

10 1.3 Schwarz a due livelli I metodi di Schwarz a due livelli hanno come principale scopo la generazione di precondizionatori che siano scalabili, permettendo di sfruttare a proprio vantaggio l aumento del numero dei sottodomini. Una prima idea è generare per il nostro problema una seconda griglia τ 0 che sarà costituita da un numero esiguo di triangoli e che, per questo motivo, verrà denominata griglia lasca o coarse in modo da distinguerla da quella principale τ h, detta griglia fine. A questa mesh possiamo facilmente associare un operatore Q 0 definito nel seguente modo: Q 0 = R T 0 A 1 0 R 0 (1.19) dove R 0 R n 0 N h è un operatore di restrizione dalla griglia fine a quella lasca e A0 R n 0 n0 è la matrice agli elementi finiti associata alla griglia coarse. Possiamo costruire l operatore R 0 utilizzando le funzioni di base della griglia coarse e calcolandone il valore nei nodi della griglia fine. Le entrate della matrice sono quindi date da: R 0 (i, j) = φ i (x j ) (1.20) dove φ i è la funzione di base associata al nodo i della griglia lasca mentre con x j indichiamo il vettore di coordinate del nodo j della griglia fine. Notiamo che per la definizione data non è necessario che i nodi della griglia coarse siano un sottoinsieme dei nodi della griglia fine, ovvero è possibile calcolare R 0 anche nel caso in cui le due griglia non siano innestate fra di loro. La natura dell operatore R T 0 è di tipo interpolativo perchè estende una soluzione grossolana su un numero maggiore di nodi attraverso l andamento delle funzioni di base della griglia fine. Grazie alla struttura di R 0 possiamo calcolare la matrice A 0 non solo attraverso la discretizzazione ad elementi del problema sulla griglia coarse, ma anche in modo equivalente come: A 0 = R 0 AR T 0 (1.21) dove A rappresenta la matrice di rigidezza calcolata sulla griglia fine. Possiamo ora facilmente estendere il precondizionatore di Schwarz additivo P as aggiungendo il contributo dell operatore Q 0 e generando il precondizionatore di Schwarz a due livelli: P 1 cas = M Q i. (1.22) Usufruendo del precondizionatore P cas nella (1.16), o nello schema numerico utilizzato, al posto del precondizionatore P as, raggiungiamo l obbiettivo della scalabilità e quindi l indipendenza dell algoritmo dal numero dei domini. Infatti è possibile dimostrare la seguente stima : i=0 K(P 1 casa) C H δ (1.23) dove C > 0 è una costante indipendente da h e H. L avere a disposizione un precondizionatore scalabile permette di scegliere un numero sempre maggiore di domini, consentendo di premiare una risoluzione di tipo parallelo e di ridurre così i tempi di calcolo rispetto ad una risoluzione tradizionale. Uno svantaggio dell approccio fin qui presentato consiste nel fatto che la costruzione di un operatore R 0 di tipo interpolativo può essere costosa, soprattutto nel caso in cui le due mesh abbiano pochi nodi interni in comune. Per ovviare a questo inconveniente si può costruire un operatore ˆR 0 definito a priori in modo più semplice: ˆR 0 (i, j) = { 1 se il nodo j Ωi, 0 altrimenti. (1.24) 8

11 L operatore ˆR 0 R M N h che abbiamo appena definito ha tante righe quanti sono il numero dei domini e tante colonne quanti sono i nodi interni della griglia fine. Definendo Â0 = ˆR 0 A ˆR 0 T, otteniamo una matrice quadrata di dimensione pari al numero dei domini scelti. Ricordandoci della decomposizione (1.11), fatta in base ai sottodomini di A, possiamo capire l azione di R 0 nella formazione di Â0. Infatti ogni elemento di Â0 è costituito dalla somma di tutti gli elementi di ciascuna sottomatrice di A. In questo caso si otterrebbe una matrice Â0 così definita: Â 0 = i,j A 1(i, j) i,j A 21(i, j) i,j A 12(i, j) i,j A 2(i, j). (1.25) Anche l azione di ˆR0 su un vettore generico v R N h è facilmente individualbile conoscendo il numero di nodi interni di ciascun sottodominio. Se consideriamo una suddivisione in due sottoregioni aventi un numero di nodi interni pari a n 1 e n 2, con ˆR 0 R 2 N h, otteniamo la seguente azione su v R N h : n1 i=1 ˆR v i 0 v =. (1.26) n2 i=n 1 +1 v i Il prodotto ˆR 0 v R 2, mostrato in (1.26), produce un vettore che ha come primo elemento la somma dei primi n 1 elementi di v e come secondo elemento la somma dei succesivi n 2 elementi di v. L operatore ˆR 0 ha quindi una natura aggregativa a causa del suo modo di operare sulle matrici e sui vettori. Come è facilmente intuibile l operatore ˆR 0 T svolge un compito opposto che potremmo definire di estensione uniforme dei valori del vettore più piccolo nella formazione del vettore di dimensione maggiore. Se ad esempio ˆR 0 T R Nh 2 e w R 2 = [w 1, w 2 ], allora ˆR 0 T w R N h ha la seguente struttura: ˆR 0 T w = w 1 w 1 w 1. w 1 w 2 w 2 w 2. w 2. (1.27) L operazione ˆR T 0 w in (1.27) produce quindi un vettore di dimensione N h, le cui prime n 1 componenti sono tutte uguali a w 1, mentre le successive n 2 componenti sono pari a w 2. Grazie all operatore ˆR 0 possiamo definire un nuovo precondizionatore a due livelli: A questo precondizionatore si può associare la seguente stima: Paggre 1 = ˆR 0 T Â 1 0 ˆR 0 + Pas 1. (1.28) K(P 1 aggrea) C(1 + H δ ) (1.29) dove C > 0 è, anche in questo caso, una costante indipendente da h e H. Possiamo notare che anche P aggre è un precondizionatore scalabile e che è quindi utile per una parallelizzazione del calcolo. Ci accorgiamo inoltre che l operatore aggregativo ˆR 0 è molto 9

12 più rapido da costruire dell operatore interpolativo R 0, perchè il primo non necessita di una seconda griglia e opera solo a livello algebrico sulle matrici o sui vettori con semplici somme. Il problema sta nel fatto che l operatore aggregativo è molto più grossolano rispetto a quello interpolativo e ciò si ripercuote in una minore velocità di convergenza come mostrato anche nella stima (1.29) rispetto alla (1.23). 10

13 Capitolo 2 Descrizione del Codice In questo capitolo viene introdotto il codice utilizzato per la programmazione degli Elementi Finiti lineari e del metodo di Schwarz per la decomposizione dei domini. Si tratta la risoluzione di problemi elittici bidimensionali, a coefficienti constanti, contenenti i termini di diffusione, reazione e trasporto. In particolare viene data prima una descrizione generale del codice e successivamente verrano spiegati i dettagli implementativi più importanti del codice. Per l utilizzo pratico del codice e per una conoscenza completa delle sue funzionalità, si rimanda alla documentazione Doxygen c presente nel pacchetto del codice. 2.1 Schema generale del codice Il codice, scritto in C++, è strutturato in header file,.hpp files contenenti la dichiarazione delle classi, e.cpp files contenenti la definizione. I sorgenti, una volta compilati, vengono raccolti nella libreria libddfem.a. Possiamo idealmente dividere il codice in due parti: una prima parte dedicata alla programmazione degli elementi finiti lineari bidimensionali e una seconda parte dedicata alla costruzione dei precondizionatori di Schwarz visti nel capitolo precedente. Una fase fondamentale nel metodo degli elementi finiti consiste nella costruzione del dominio di calcolo. Per la generazione della griglia ci siamo avvalsi del software esterno Triangle c 1, che permette di generare triangolazioni di Delaunay per domini bidimensionali. La classe adibita alla memorizzazione dei triangoli e dei nodi, classe Mesh, è contenuta nel file mesh.hpp. Poichè nella nostra trattazione siamo interessati alla risoluzione di un problema elittico tramite il metodo di decomposizione dei domini, la classe Mesh, oltre a contenere le informazioni topologiche del dominio di calcolo, racchiude le informazioni riguardanti il numero dei domini in cui viene suddiviso il problema e i nodi interni appartenenti ad ogni dominio. Per la partizione del dominio abbiamo utilizzato il software esterno Metis c 2 ; fornito un file contenente i nodi appartenenti ad ogni triangolo, il programma tramite l utilizzo del comando partdmesh partiziona i nodi della mesh in modo da distribuirli equamente tra i vari domini. La partizione ottenuta è equivalente ad una suddivisione dei domini con overlap minimo, ovvero con sovrapposizione pari ad una sola striscia di elementi finiti come in Figura 2.2. Il file base function.hpp contiene le informazioni funzionali degli elementi finiti lineari, ovvero le funzioni di base lagrangiane e i rispettivi gradienti riferiti all elemento di riferimento. Una volta scelta la formula di quadratura, contenuta nel file quadrature.hpp, il codice prevede l assemblamento dei diversi termini del problema elittico e quindi della matrice associata alla discretizzazione del problema. Il file assembla.hpp contiene le funzioni adibite alla costruzione dei termini di diffusione, trasporto, reazione e del termine noto. Il formato di memorizzazione utilizzato per la matrice elementi finiti è quello CSC, Compressed 1 Per maggiori dettagli consultare l appendice A 2 Per maggiori dettagli sull utilizzo del programma consultare l appendice 11

14 Figura 2.1: Esempio di griglia generata tramite Triangle c sul dominio Ω = [0, 1] [0, 1]. Figura 2.2: Suddivisione in otto domini del quadrato Ω = [0, 1] [0, 1] generata dal partizionatore Metis c. La zona colorata in bianco corrisponde alla sovrapposizione di una sola striscia di elementi. 12

15 Sparse Column. La scelta deriva dall utilizzo della libreria esterna di algebra lineare UMF- PACK, utile per la risoluzione di sistemi lineari tramite fattorizzazione LU, che opera con matrici memorizzate nel formato CSC. La parte di codice riguardante l implementazione degli elementi finiti lineari termina con il file problem.hpp, contenente la classe Problem, in cui si gestisce la costruzione del particolare problema elittico, l imposizione delle condizioni al bordo e la risoluzione del sistema lineare (1.10). Il codice tratta condizioni al bordo di Dirichlet omogenee, non omogenee e condizioni di Neumann omogenee. Il metodo di decomposizione dei domini di Schwarz additivo consiste per ogni dominio eseguire le seguenti operazioni: restringere il residuo r, R i r, risolvere il sistema A i z = R i r e successivamente riportare la soluzione del dominio sul dominio globale. Il file domain.hpp contiene la classe per la gestione del generico dominio della partizione e le classi per la gestione dei correttori coarse presentati precedentemente. Ogni dominio utilizza il metodo diretto implementato in UMFPACK come metodo di risoluzione del sistema lineare. I precondizionatori (1.17), (1.22) e (1.28) vengono dichiarati in preconditioner.hpp e definiti nel corrispondente.cpp file. Infine per la risoluzione del sistema lineare si è utilizzato il metodo iterativo BI-CGSTAB con precondizionatore di tipo Domain Decomposition. Abbiamo scelto di utilizzare tale metodo perchè non presenta limitazioni per quanto riguarda la simmetria della matrice e ha buone proprietà di convergenza. Il codice quindi una volta costruita la matrici ad elementi finiti prevede due modi di risolvere un problema di tipo elittico: tramite risoluzione diretta del sistema lineare senza introdurre alcuna partizione del dominio, oppure tramite metodo iterativo sfruttando la decomposizione dei domini. Infine il codice prevede una fase di post-processing in cui viene memorizzata su file la soluzione per la rappresentazione grafica tramite il programma Xd3d. Per un elenco completo di tutti gli.hpp files presenti nella libreria si rimanda alla documentazione Doxygen c presente nella cartella doc. 13

16 Triangle geometry.hpp Metis Mesh FE_Matrix Pattern matrice EF base_function.hpp assembla.hpp Istanzia problema problem.hpp Metodo di risoluzione Risoluzione esatta do_solution Metodo iterativo precondizionatore di Schwarz domain.hpp preconditioner.hpp post_processing Risoluzione tramite BI CGSTAB Figura 2.3: Schema generale del codice. 14

17 2.2 Dettagli implementativi Le classi Point2D e Triangle Le classi Point2D e Triangle sono adibite alla memorizzazione delle informazioni topologiche della mesh. In particolare la classe Point2D è la struttura dati per la memorizzazione delle coordinate di un punto bidimensionale, la sua numerazione all interno della griglia, l etichetta identificativa del dominio di appartenenza e infine l etichetta per tenere traccia dei nodi di bordo. Abbiamo scelto come convenzione di assegnare 1 se il nodo è di bordo, 0 altrimenti. Per quanto riguarda l etichetta identificativa del dominio, il partizionatore Metis c fornisce delle etichette a partire da 0 fino al numero dei domini meno uno. La classe Triangle si occupa invece di memorizzare un elemento finito lineare, ovvero contenente tre nodi. Possiede al suo interno l etichetta dell elemento, la struttura std::vector<point2d> per la memorizzazione dei tre nodi e un vettore di double contenente la matrice dei cofattori dello Jacobiano di trasformazione dall elemento corrente all elemento di riferimento. In seguito sarà spiegato in maniera più dettagliata la motivazione dell introduzione della matrice Jacobiana La classe Mesh La classe si occupa di memorizzare la griglia generata da Triangle c. I nodi e i triangoli della mesh vengono memorizzati nelle strutture std::vector<triangle> grid e std::vector<point2d> nodes. La classe presenta diversi metodi, ci apprestiamo ad analizzarne due molto importanti: il metodo renumerate nodes per la rinumerazione dei nodi e l algoritmo per trovare il pattern di sparsità della matrice EF associata alla griglia. La rinumerazione dei nodi della griglia viene eseguita in modo da poter applicare il metodo di decomposizione dei domini alla matrice A, ovvero in modo da ottenere una struttura a blocchi della matrice come affermato in (1.12). Riportiamo di seguito il codice: void Mesh::renumerate_nodes(){ int domain=1; int boundary=np; std::vector<int>* index(0); index=new std::vector<int> [Ndom]; for (int i=0;i<ndom;++i){ index[i].reserve(np/ndom);} for (int j=0;j<np;++j){ if(nodes[j].get_id_boundary()==1){ nodes[j].change_id_node(boundary); dir_idx.push_back(j); boundary-=1;} else{ for (int i=0;i<ndom;++i){ if(nodes[j].get_id_domain()==i){ index[i].push_back(j); break;}}} } for(int k=0;k<ndom;++k){ for(int j=0;j<index[k].size();++j){ nodes[index[k][j]].change_id_node(domain); domain+=1;}} 15

18 for(int k=0;k<ndom;++k){ domain_node.push_back(index[k].size());} delete[] index; first_dirichlet=boundary+1;} Per prima cosa viene costruito un puntatore a vettore di interi, std::vector<int>* index, di dimensione pari al numero dei domini; per ogni elemento viene riservata un area di memoria pari al numero dei nodi totali diviso il numero dei domini. Il puntatore è pensato per contenere in ogni elemento la lista dei nodi interni appartenenti ad ogni dominio; ad esempio l elemento di posizione index[0] conterrà la lista dei nodi interni appartenenti al primo dominio e così via per gli altri elementi. Nella rinumerazione si lasciano i nodi di bordo per ultimi; ovvero se la mesh è costituita da Np nodi di cui Nd di bordo, i nodi di bordo avranno le etichette comprese tra Np + 1 Nd e Np. Si esegue quindi il ciclo sui nodi della mesh. Il primo if controlla che il nodo in questione sia di bordo; se è di bordo viene modificata l etichetta e viene memorizzata in std::vector<int> dir idx la sua posizione all interno del vettore nodes. Quest ultima operazione ci permette di accedere facilmente ai nodi di bordo ed è quindi molto utile nell imposizione delle condizioni al bordo. Se il nodo in questione non è di bordo, si cicla sul numero dei sottodomini e si cerca l appartenenza del nodo ad un dominio. Una volta trovata l appartenenza del nodo al dominio, si inserisce in index la sua posizione occupata nel vettore dei nodi. In questo modo siamo in grado di sapere la lista dei nodi interni appartenenti ad ogni dominio e quindi siamo pronti per la rinumerazione. Si parte dal primo dominio e si riassegnano ai nodi le etichette a partire da 1 a n 1 3, per il secondo dominio da n a n 2 e così via per gli altri domini. Il metodo memorizza inoltre il numero di nodi interni per dominio(std::vector<int> node d) e l etichetta del primo nodo di bordo. Introduciamo ora il metodo find neigh che genera il pattern della matrice. Per memorizzare il pattern abbiamo utilizzato un puntatore a liste di interi della libreria STL(std::list<int>* near). La struttura di sparsità della matrice equivale a calcolare il supporto di ogni funzione di base ϕ j, ovvero cercare per ogni nodo j i nodi vicini come illustrato in figura 1.2. Il puntatore a liste di interi contiene quindi per ogni elemento in posizione j 1 l etichette dei nodi vicini riscalate di uno. Riportiamo di seguito il codice: void Mesh::find_neigh(){ for (int i=0;i<ne;++i){//ciclo sugli elementi della griglia for(int j=0;j<3;++j){ for(int k=0; k<3;++k){ near[grid[i].get_vertices(j)-1].push_back(grid[i].get_vertices(k)-1);}}} for(int i=0;i<np;++i){ near[i].sort(); near[i].unique();}} Come possiamo osservare dal codice, per ogni triangolo i della griglia, si seleziona un nodo di etichetta j e si inseriscono in posizione j 1 l etichette dei nodi appartenenti allo stesso triangolo, compresa j 1, riscalate di uno. Il procedimento si ripete per tutti e tre i nodi appartenenti al triangolo i. Con questo procedimento, dopo aver ciclato su tutti gli elementi, si ottiene per ogni nodo una lista di vicini con delle ripetizioni, in quanto un nodo appartiene a più di un triangolo. L header file <list> della STL, permette l utilizzo delle funzioni sort e unique che rispettivamente ordinano gli elementi di una lista e eliminano gli elementi ripetuti. Pertanto ciclando sugli elementi del puntatore near, le liste vengono prima riordinate e poi vengono eliminate le ripetizioni in modo da ottenere il pattern della matrice. 3 Numero dei nodi interni del primo dominio 16

19 2.2.3 Le classi Template Queste classi, tutte raccolte nel header file function.hpp, si occupano della gestione di tipi complessi. L idea è utilizzare le classi template e funtori per poter valutare i diversi addendi di un integrale nei nodi di una qualsiasi formula di quadratura. Inoltre un approccio che sfrutti i funtori permette di incrementare l efficienza di un programma che debba invece usare i puntatori a funzione per realizzare gli stessi obiettivi. Il tassello base è la classe template<double F(double,double)> Functor, della quale riportiamo la definizione: template<double F(double,double)> class Functor{ public: double operator()(double x,double y){return F(x,y);} }; Questa classe utilizza una funzione come paramentro template e, ridefinedo l operatore (), permette di mantenere la caratteristica della funzione double F(double,double) di essere valutata correttamente nei suoi argomenti. A questo punto disponiamo del nuovo tipo Functor che può essere impiegato per la costruzione di classi template più complesse. La classe template<class T, class U> Function product restituisce il prodotto di due oggetti template generici per i quali è stato sovraccaricato l operatore (). La definizione di questa classe risulta: template<class T, class U> class Function_product { //Oggetto di tipo T T F1; //Oggetto di tipo U U F2; public: Function_product(){} Function_product(T a):f1(a){} Function_product(T a,u b):f1(a),f2(b){} double operator()(double x,double y){return F1(x,y)*F2(x,y);} }; In modo analogo la classe template<class T> class F change coord sovraccarica l operatore () per effettuare il cambio di coordinate di un oggetto template di tipo T generico, data una generica mappa lineare affine. È utile per l integrazione di funzioni che devono essere mappate. Per operare con i gradienti di funzione è comodo utilizzare una classe template che rappresenti un vettore bidimensionale di oggetti generici. Questo scopo è realizzato dalla classe template <class T, class U> class VCR, della quale riportiamo la definizione: template <class T, class U> class VCR{ //Prima componente T v1; //Seconda componente U v2; public: VCR(){} VCR(T a,u b): v1(a),v2(b){} inline T& get_v1(){return v1;} 17

20 inline U& get_v2(){return v2;} }; I suoi metodi get v1() e get v2() permettono di accedere rispettivamente alla prima e alla seconda componente del vettore. La classe Vcr può essere utilizzata in combinazione alla classe Functor per istanziare vettori bidimensionali di funzioni, ma può anche essere usata per creare vettori di oggetti più complicati. Per gestire l operazione di prodotto scalare, viene impiegata la classe template <class T, class U, class V, class Z> class Inn che memorizza quattro tipi generici in due vettori della classe Vcr. Chiamando l operatore tonda su un oggetto di classe Inn si realizza il prodotto scalare usuale tra i due vettori di tipo Vcr, impiegati come attributi della classe. La descrizione dettagliata di questa classe è di seguito riportata: template <class T, class U, class V, class Z> class Inn{ //Vettore di componenti T e U VCR<T,U> F1; //Vettore di componenti V e Z VCR<V,Z> F2; public: Inn (){}; Inn(T a,u b,v c,z d): F1(a,b),F2(c,d){} double operator ()(double x, double y){ return F1.get_v1()(x,y)*F2.get_v1()(x,y)+F1.get_v2()(x,y)*F2.get_v2()(x,y);} }; Per la classe Inn è anche necessaria una specializzazione nel caso in cui si debba operare con un prodotto scalare tra un vettore Vcr generico e un vettore di double. Bisogna infatti prestare attenzione al fatto che i double non dispongono dell operatore parentesi tonda e, in quel caso, si avrebbe un errore nella ridefinizione di tale operatore nella classe Inn. La ridefinizione corretta per la classe specializzata template <class U,class V> class Inn <double,double,u,v> diventa quindi: ///Ridefinizione operatore parentesi tonda in modo che ritorni il prodotto scalare tra un vettore di double e uno di tipo generico valutato nelle coordinate x e y. double operator ()(double x,double y){ return scalar.get_v1()*fun.get_v1()(x,y)+scalar.get_v2()*fun.get_v2()(x,y);} La combinazione di tutte queste classi permette di risolvere i problemi legati all integrazione dei diversi termini della forma bilineare nel generico problema ellittico (1.5). L utilizzo di classi annidate fra loro, ciascuna delle quali ridefinisce l operatore parentesi tonda, consente di emulare la componibilità delle funzioni che, a partire da funzioni semplici, generano nuove funzioni più complesse. Questo impianto diviene conveniente per svincolare completamente la formula di quadratura scelta dai diversi argomenti dell integrale. Inoltre le dipendenze fra le diverse classi vengono autamaticamente risolte in fase di compilazione, incrementando così l efficienza a run-time La classe Quadrature La classe si occupa di memorizzare ed implementare la formula di quadradura necessaria al calcolo degli integrali. La formula di quadratura utilizzata fa parte delle cosiddette formule 18

21 simmetriche per elementi triangolari. Infatti i nodi occupano posizioni simmetriche quando vengono utilizzate sul triangolo di riferimento. Consideriamo un generico triangolo T e chiamiamo a i, i = 1, 2, 3, i vettori delle coordinate dei suoi tre vertici, con a (j), j = 1, 2, 3 i punti medi dei sui lati e con a m il suo baricentro. Con queste definizioni, vale la seguente formula di quadratura a sette nodi con grado di esattezza 3: I 7 (f) = T ( f(a i ) + 8 i=1 3 j=1 ) f(a (j) ) + 27f(a m ). (2.1) La formula di integrazione (2.1) è quella utilizzata nel codice, applicata al triangolo di riferimento di vertici ˆx 0 = (0, 0), ˆx 1 = (1, 0) e ˆx 2 = (0, 1). La definizione dettagliata della classe è di seguito riportata: class Quadrature { private: //Coordinate x dei punti medi dei lati e punto medio triangolo. Memorizzate in senso antiorario. std::vector<double> nodes_x; //Coordinate y dei punti medi dei lati e punto medio triangolo. Memorizzate in senso antiorario. std::vector<double> nodes_y; //Vettore dei pesi std::vector<double> weight; public: Quadrature(); template <class F> double integrate (F fun); }; //definizione funzione template template <class F> double Quadrature::integrate(F fun){ double result=0; for (int i=0;i<7;++i){ result+=weight[i]*fun(nodes_x[i],nodes_y[i]);} return 0.5*result;} } La classe memorizza le ascisse dei nodi di quadratura nel vettore std::vector<double> nodes x, le ordinate nel vettore std::vector<double> nodes y e i pesi nel vettore std::vector<double> weight. Il metodo template <class F> double integrate (F fun) è una funzione template che valuta la funzione generica fun nei nodi di quadradura e la moltiplica per i rispettivi pesi. Il risultato viene infine moltiplicato per 0.5 che corrisponde al T della formula (2.1), ovvero all area del triangolo di riferimento. Possiamo notare come il parametro fun possa essere un oggetto generico, anche complicato, purchè dotato di ridefinizione dell operatore parentesi tonda. Grazie all uso dei funtori, definiti nella sezione precedente, siamo riusciti a separare completamente la regola di integrazione dal tipo di integrale che si vuole calcolare. Se volessimo scegliere una diversa formula di quadratura sarebbe quindi sufficiente modificare i vettori dei nodi e quello dei pesi, senza dover cambiare in alcun modo le definizioni delle classi template. 19

22 2.2.5 La classe FE Matrix Questa classe implementa la memorizzazione e la gestione delle matrici sia quadrate che rettangolari, con particolare attenzione a quelle generate da una risoluzione ad elementi finiti, sfruttando il formato sparso CSC (Compressed Sparse Column). La scelta di questo formato è imposta dalla necessità di interfacciarsi con la libreria esterna UMFPACK per la risoluzione esatta dei sistemi lineari. Il formato CSC è composto da tre vettori rows, columns e matrix che contengono rispettivamente gli indici di riga riscalati di uno, gli indici del vettore rows di inizio di una nuova colonna e i valori degli elementi non nulli. Per comprendere meglio il tipo di memorizzazione consideriamo la seguente matrice d esempio: A = Nel formato CSC la matrice A diviene: columns = [0, 2, 5, 9, 10, 12], rows = [0, 1, 0, 2, 4, 1, 2, 3, 4, 2, 1, 4], matrix = [2, 3, 4, 9, 5, 4, 7, 1, 3, 8, 6, 2].. (2.2) Il vettore columns fa da puntatore agli elementi del vettore rows che rappresentano l inizio di una nuova colonna. Nel nostro esempio la prima colonna di A inizia all indice 0 di rows, la seconda colonna all indice 2, la terza all indice 5, e così via. In questo modo, se columns[k] è il contenuto del vettore columns, ogni colonna contiene esattamente columns[k+1]-columns[k] elementi non nulli. Il vettore rows raccoglie gli indici di riga, riscalati di uno, degli elementi non nulli di ciascuna colonna di A. Il vettore matrix memorizza, invece, i valori numerici degli elementi non nulli della matrice A letti per colonne. Quindi il vettore columns ha lunghezza ncol + 1, dove ncol indica il numero di colonne della matrice (2.2), mentre i vettori rows e matrix hanno lunghezza nz pari al numero di elementi non nulli. Gli attributi della classe FE Matrix sono quindi i seguenti: class FE_Matrix { private: //Puntatore alle colonne int* columns; //Puntatore alle righe int* rows; //Puntatore agli elementi della matrice double* matrix; //Numero di colonne int ncol; //Numero di elementi non nulli int nz; //Numero di righe int nrow; Sono stati utilizzati gli array con memoria dinamica al posto dei std::vector<>, per essere conformi con le richieste della libreria esterna UMFPACK. Per costruire la matrice ad elementi finiti di un problema si sfrutta il seguente costruttore della classe: 20

23 FE_Matrix::FE_Matrix(int Ncol, int Nz, std::list<int>* neigh): columns(0), rows(0), matrix(0){ ncol=ncol; nz=nz; nrow=ncol; columns= new int[ncol+1]; rows=new int[nz]; matrix=new double[nz]; irow k;//iteratore al vicino for(int i=0;i<ncol+1;++i){ columns[i]=0;} for(int i=0;i<nz;++i){ rows[i]=0; matrix[i]=0;} for (int j=1;j<ncol+1;++j){ columns[j]=columns[j-1]+neigh[j-1].size();}//riempie il vettore delle colonne for (int j=0;j<ncol;++j){ k=neigh[j].begin();//iteratore all vicino j for(int i=columns[j];i<columns[j+1];++i){ rows[i]=*k;//riempie il vettore delle righe ++k;} } } Esso prende come paramentri in ingresso due interi e un puntatore a liste di interi. Ncol rappresenta il numero di colonne della matrice mentre il puntatore a liste, neigh, contiene il pattern della matrice, come spiegato nel paragrafo relativo alla classe Mesh. Nz è invece il numero di elementi non nulli della matrice. Questo costruttore, utilizzando la conoscenza della struttura della matrice, riempe i vettori columns e rows, mentre alloca la memoria per il vettore matrix ponendo momentaneamente tutti i suoi elementi a zero. La fase di riempimento del vettore matrix può avvenire in maniera incrementale tramite il metodo fill Matrix(int i, int j, double value). Questo, dati gli indici i e j di riga e colonna, esegue l operazione a ij = a ij + value. Una volta assemblata la matrice agli elementi finiti risulta conveniente disporre di un metodo per orlarla dati un certo indice di riga e di colonna. Grazie alla rinumerazione dei nodi sappiamo con sicurezza che i nodi di bordo sono numerati per ultimi. Infatti nell imposizione delle condizioni di Dirichlet omogenee, per eliminare i gradi di liberta relativi ai nodi di bordo, nei quali si conosce la soluzione, è sufficiente conoscere l etichetta del primo nodo di Dirichlet. Il metodo che si occupa di orlare la matrice si chiama bc dirichlet(int idb,int idb row), nel quale idb (index dirichlet boundary) rappresenta l etichetta del primo nodo di Dirichlet. Il parametro idb row è necessario in cui si voglia orlare la matrice sulle righe in modo diverso rispetto alle colonne. Per le matrici ad elementi finiti si ha sempre idb=idb row. Se per esempio consideriamo di avere 6 nodi, numerati da 1 a 6, di cui 4 di bordo, allora si ha idb = 3, ovvero il primo nodo di Dirichlet è il numero 3. Se la matrice di partenza M R 6 6 fosse M =

24 allora applicando la funzione bc dirichlet(int idb,int idb row) si arriverebbe ad una matrice M R 2 2 così fatta: [ ] 2 4 M =. 3 0 Il metodo transpose() genera la trasposta della matrice e la memorizza nel formato CSR sovrascrivendo i vettori columns, rows e matrix. L utilizzo di questo metodo equivale alla possibilità di convertire il formato CSC in quello CSR (Compressed Sparse Row). Questa operazione è utile quando si vuole eseguire un prodotto matrice per vettore. Infatti nel formato CSC è semplice accedere agli elementi non nulli di una colonna, mentre è più difficile accedere alle righe. Per questo motivo convertire il formato da CSC a CSR permette di accedere velocemente alle righe. La conversione del formato sfrutta la funzione umfpack di transpose della libreria UMFPACK. Il metodo prod(double* const res, const double* const x) si occupa invece di eseguire il prodotto tra la matrice A R n m in formato CSR e un vettore x R m, restituendo il risultato in un vettore res R n. void FE_Matrix::prod(double* const res, const double* const x){ for(int i=0;i<ncol;++i){ res[i]=0;} for(int i=0;i<ncol;++i){ for(int j=columns[i];j<columns[i+1];++j){ res[i]+=matrix[j]*x[rows[j]];}} } Per utilizzare il metodo prod() è importante accertarsi che la matrice A sia memorizzata in formato CSR, in modo tale da permettere un accesso rapido alle righe della matrice stessa. Quindi se si vuole eseguire il prodotto di una matrice memorizzata in formato CSC con un vettore è prima necessario convertire il formato attraverso la funzione transpose(). Cosideriamo ora i metodi della classe FE Matrix collegati alla domain decomposition. In particolare trattiamo quei metodi che permettono l estrazione di sottomatrici data una matrice pricipale A, implementando la decomposizione (1.12). Il metodo extract columns(int Dnum,std::vector<int> node d,std::vector<fe Matrix>& submatrix col) seziona la matrice di partenza per colonna. In particolare genera un numero di sottomatrici pari al numero dei domini Dnum e assegna a ciascuna sottomatrice A i, i = 1,..., Dnum, un numero di colonne pari all intero di posto i 1 del vettore node d. Quest ultimo vettore, di lunghezza Dnum, contiene quanti nodi interni ci sono in ogni sottodominio. Il risultato del metodo extract columns() è una collezione di sottomatrici in formato CSC che vengono salvate nel vettore submatrix col. Se per esempio consideriamo la matrice A introdotta nell esempio (2.2) e poniamo Dnum=3 e node d=[2,1,2], allora la decomposizione che si ottiene è la seguente: A = , ovvero le sottomatrici A 1 = A 2 = A 3 =