DSF Implementation

Well...the following is the C++ code to achieve the initial stages of the DSF (e.g. member formation, globalization, merging and linear solving):
main.cpp:
#include <iostream> #include <math.h> #include "Stiffness.h" #include <vector> #include <gsl/gsl_matrix.h> #include <gsl/gsl_blas.h> #include <time.h> #include <ctime> #include <stdio.h> #include <unistd.h> #include <stdlib.h> int main() { struct timespec start, stop1, stop2,stop3; double accum; clock_gettime( CLOCK_REALTIME, &start); vector<Element> Elements; vector<Node> Nodes; Element Ele; Node Node; int numelements=0; int numnodes=0; //Create an structure of ten flat meshes one on top of the next //In total makes 1000 nodes and 1800 elements for (int h=0;h<10;h++) { for (int i=0;i<=9;i++) { for (int j=0;j<9;j++) { Ele.A=1; Ele.E=100; Ele.nodei=h*100+10*i+j; Ele.nodej=h*100+10*i+j+1; Elements.push_back(Ele); numelements++; } } for (int i=0;i<=9;i++) { for (int j=0;j<9;j++) { Ele.A=1; Ele.E=100; Ele.nodei=h*100+10*j+i; Ele.nodej=h*100+10*j+i+10; Elements.push_back(Ele); numelements++; } } for (int i=0;i<10;i++) { for (int j=0;j<10;j++) { Node.Coordinates[0]=10*i; Node.Coordinates[1]=10*j; Node.Coordinates[2]=h*50; Node.DOF[0]=1; Node.DOF[1]=1; Node.DOF[2]=1; Node.Forces[0]=0; Node.Forces[1]=0; Node.Forces[2]=-10; Node.PrescribedDisplacements[0]=0; Node.PrescribedDisplacements[1]=0; Node.PrescribedDisplacements[2]=0; Nodes.push_back(Node); numnodes++; } } } printf("Number of elements:%d\n",numelements); printf("Number of nodes:%d\n",numnodes); printf("Assembling...\n"); Structure *Fem=new Structure(Elements,Nodes); Fem->SpaceTrussMasterStiffness(); printf("Assembled!\n"); // printf("***********************************************************************\n"); // printf("*******************************Kg Matrix*******************************\n"); // printf("***********************************************************************\n"); // for (int i=0;i<=Fem->NumNodes*3-1;i++) // { // for (int j=0;j<=Fem->NumNodes*3-1;j++) // { // printf("%6.2f,",gsl_matrix_get(Fem->Kg,i,j)); // } // printf("\n"); // } clock_gettime( CLOCK_REALTIME, &stop1); accum = ( stop1.tv_sec - start.tv_sec ); printf( "Elapsed time (ms): %4.6f\n", accum ); Fem->ModifiedMasterStiffness(Fem->Kg); // // printf("***********************************************************************\n"); // printf("*************************Forces Vector*********************************\n"); // printf("***********************************************************************\n"); // for (int i=0;i<Fem->NumNodes*3;i++) // { // printf("%g ", gsl_vector_get(Fem->VectorForces,i)); // } Fem->ModifiedNodeForces(); printf("Solving...\n"); Fem->LinearSolve(Fem->Kg,Fem->VectorForces); delete Fem; clock_gettime( CLOCK_REALTIME, &stop2); accum = ( stop2.tv_sec - stop1.tv_sec ); printf( "Elapsed time (ms): %4.6f\n", accum ); clock_gettime( CLOCK_REALTIME, &stop3); accum = ( stop3.tv_sec - start.tv_sec ); printf( "Total elapsed time (ms): %4.6f\n", accum ); };
Element.h:
#ifndef ELEMENT_H_ #define ELEMENT_H_ class Element { public: Element(); virtual ~Element(); double A; double E; double L; int nodei; int nodej; double Sigma; double IntForces; }; #endif /*ELEMENT_H_*/ Element.cpp:
#include "Element.h" Element::Element() { } Element::~Element() { } Node.h:
#ifndef NODE_H_ #define NODE_H_ #include <iostream> #include <vector> using namespace std; class Node { public: Node(); ~Node(); vector<double> Coordinates; vector<double> DOF; vector<double> Forces; vector<double> PrescribedDisplacements; }; #endif /*NODE_H_*/ Node.cpp:
#include <iostream> #include "Node.h" using namespace std; Node::Node() { Coordinates.resize(3); DOF.resize(3); Forces.resize(3); PrescribedDisplacements.resize(3); } Node::~Node() { }  
Stiffness.h:
#ifndef STIFFNESS_H_ #define STIFFNESS_H_ #include <iostream> #include <vector> #include <gsl/gsl_matrix.h> #include <gsl/gsl_blas.h> #include "Node.h" #include "Element.h" using namespace std; class Structure { public: int NumNodes; int NumElements; vector<Node::Node> Nodes; vector<Element::Element> Elements; vector<double> PrescDOFTable; vector<double> PrescForcesTable; gsl_matrix *Kg; gsl_vector *VectorForces; Structure(vector<Element>,vector<Node>); ~Structure(); void SpaceTrussSolution(); void SpaceTrussMasterStiffness(); void ModifiedMasterStiffness(gsl_matrix*); void ModifiedNodeForces(); void SpaceTrussStresses(); void SpaceBar2Stiffness(vector<double>, vector<double>, double , double , gsl_matrix*); void PrescDisplacementDOFS(); void LinearSolve (gsl_matrix*,gsl_vector*); }; #endif /*Structure_H_*/  
Stiffness.cpp:
#include <iostream> #include <string> #include <cstdio> #include <vector> #include <math.h> #include <gsl/gsl_matrix.h> #include <gsl/gsl_blas.h> #include <gsl/gsl_linalg.h> #include "Stiffness.h" #include "Node.h" #include "Element.h" using namespace std; Structure::Structure(vector<Element> ImpElements,vector<Node> ImpNodes) { printf("Initializing...\n"); Elements=ImpElements; Nodes=ImpNodes; NumElements=Elements.size(); NumNodes=Nodes.size(); Kg = gsl_matrix_alloc(NumNodes*3,NumNodes*3); VectorForces=gsl_vector_alloc(NumNodes*3); int counter=0; int n1=Nodes.size(); int n2=3; for (int i=0;i<n1;i++) { for (int j=0;j<n2;j++) { gsl_vector_set(VectorForces,counter,Nodes[i].Forces.at(j)); counter+=1; } } // printf("Creating DOF table...\n"); this->PrescDisplacementDOFS(); // printf("Created!\n"); // printf("Initialized!\n"); } Structure::~Structure() { printf("Removing data...\n"); gsl_matrix_free( this->Kg ); } void Structure::SpaceTrussMasterStiffness() { int ii,jj; printf("Assembling...\n"); for (int e=0; e<NumElements; e++) { gsl_matrix *Ke=gsl_matrix_alloc(6,6); Element Ele=Elements.at(e); // printf("**********************************************\n"); // printf("Processing element (%d)\n", e); // printf("**********************************************\n"); int ni=Ele.nodei; int nj=Ele.nodej; int eftab[6]={3*(ni+1)-3,3*(ni+1)-2,3*(ni+1)-1,3*(nj+1)-3,3*(nj+1)-2,3*nj+1)-1}; SpaceBar2Stiffness(Nodes[ni].Coordinates,Nodes[nj].Coordinates,Ele.E,Ele.A,Ke); int neldof=Ke->size1; for (int i=0; i<=neldof-1; i++) { ii=eftab[i]; for (int j=i; j<=neldof-1; j++) { jj=eftab[j]; gsl_matrix_set(this->Kg,ii,jj, gsl_matrix_get(this->Kg,ii,jj) +gsl_matrix_get(Ke,i,j)); gsl_matrix_set(this->Kg,jj,ii, gsl_matrix_get(this->Kg,ii,jj)); } } gsl_matrix_free( Ke ); // printf("Inserted!\n"); } } void Structure::ModifiedMasterStiffness(gsl_matrix *K) { int i,n,np; np=PrescDOFTable.size(); n=K->size1; printf("Modifying Kg...\n"); for (int k=0;k<np;k++) { i=PrescDOFTable.at(k); for (int j=0;j<n;j++) { gsl_matrix_set(K,i,j,0); gsl_matrix_set(K,j,i,0); gsl_matrix_set(K,i,i,1); } } } void Structure::ModifiedNodeForces() { int i,np,d,n,counter(0); printf("Modifying force vector...\n"); np=PrescDOFTable.size(); n=Kg->size1; int n1,n2; n1=Nodes.size(); n2=3; for (int i=0;i<n1;i++) { for (int j=0;j<n2;j++) { gsl_vector_set(VectorForces,counter,Nodes[i].Forces.at(j)); counter+=1; } } int c[n]; for (int k=0;k<np;k++) { i=PrescDOFTable.at(k); c[i]=0; } for (int k=0;k<np;k++) { i=PrescDOFTable.at(k); d=PrescForcesTable.at(k); gsl_vector_set(VectorForces,i,d); if (d==0) { continue; } for (int j=0;j<n;j++) { gsl_vector_set(VectorForces,j,gsl_matrix_get(Kg,i,j)*c[j]*d); } } printf("\n"); } void Structure::LinearSolve (gsl_matrix *a, gsl_vector *b) { gsl_vector *x=gsl_vector_alloc (a->size1); int s; gsl_permutation *p=gsl_permutation_alloc (a->size1); gsl_linalg_LU_decomp (a, p, &s); gsl_linalg_LU_solve (a, p, b, x); gsl_permutation_free (p); } void Structure::SpaceBar2Stiffness(vector<double> coor1, vector<double> coor2, double Em, double A, gsl_matrix *Ke) { double x21,y21,z21,EA,L,LL; x21=coor2.at(0)-coor1.at(0); y21=coor2.at(1)-coor1.at(1); z21=coor2.at(2)-coor1.at(2); EA=Em*A; LL=x21*x21+y21*y21+z21*z21; L=sqrt(LL); double Kaux[6][6] = { { x21*x21, x21*y21, x21*z21,-x21*x21,-x21*y21,-x21*z21}, { y21*x21, y21*y21, y21*z21,-y21*x21,-y21*y21,-y21*z21}, { z21*x21, z21*y21, z21*z21,-z21*x21,-z21*y21,-z21*z21}, {-x21*x21,-x21*y21,-x21*z21, x21*x21, x21*y21, x21*z21}, {-y21*x21,-y21*y21,-y21*z21, y21*x21, y21*y21, y21*z21}, {-z21*x21,-z21*y21,-z21*z21, z21*x21, z21*y21, z21*z21} }; for (int i=0; i<6;i++) { for (int j=0; j<6;j++) { gsl_matrix_set(Ke,i,j,(EA/(L*L*L))* Kaux[i][j]); } } } void Structure::PrescDisplacementDOFS() { int k,index; k=0; for (int n=0;n<NumNodes;n++) { for (int j=0;j<3;j++) { index=Nodes.at(n).DOF[j]; if (index>0) { PrescDOFTable.push_back(k+j); PrescForcesTable.push_back(Nodes.at(n).Forces[j]); } } k+=3; } }

I have used the GSL library for everything related to maths (http://www.gnu.org/software/gsl/).
This will make my life a lot easier once I manage to master it...Is fairly well documented, so it won't take long (I hope).
Please note that to make the timer work, under Ubuntu 9.10, I've had to activate the -lrt tag in the linker.