/**
* int main()
*
* Descricao:
* Funcao principal do programa que contem um loop (do-while) contendo a chamada
* das funcoes que calculam as variaveis utilizadas pelo algoritmo Gauss-Legendre
* a cada iteracao.
*
* Parametros de entrada:
* -
*
* Parametros de retorno:
* -
*
*/
int main(){
/* Variaveis utilizadas para calcular o tempo de execucao do programa */
time_t begin, end;
double time_spent;
time(&begin);
/* Inicialicazao das variaveis globais utilizadas no algoritmo */
initAttributes();
/* Loop principal que calcula o valor do "pi" */
do{
//printf("Iteracao: %ld\n", n_count);
calculate_a();
calculate_b();
calculate_t();
calculate_p();
calculate_pi();
filePrint();
n_count++;
} while(mpf_cmp(pi[n_count-2], pi[n_count-1])!=0); /* Condicao de parada: o "pi" recem calculado deve
ser igual ao seu antecessor, garantindo assim a sua
convergencia com 10 milhoes de casas decimais */
time(&end);
time_spent = difftime(end, begin);
printf("Tempo de execucao: %lf segundos\nIteracoes: %ld\n", time_spent, n_count);
return 0;
}
double kernelCPU(int iteration, float *Sign, int *EtoV,
double *h1, double *u1, double *v1, double *hu1, double *hv1,
double *h, double *u, double *v, double *hu, double *hv,
double *L, int *EtoE, double *normx, double *normy, double *AREA, double dt, int Nelems)
{
double hj, hk, uj, uk, vj,vk, huj, huk, hvj, hvk;
double a_plus, a_min;
double HUj, HUk, nx, ny, l, A;
int look=0;
double start_time;
start_time = cpuSecond();
for(int it=0;it<iteration; it++)
{
for(int idx=0; idx<Nelems;idx++)
{
double Flux_h=0.0, Flux_hu=0.0, Flux_hv=0.0;
//fill common elements
hj=h[idx];
uj=u[idx];
vj=v[idx];
huj=hu[idx];
hvj=hv[idx];
A=AREA[idx];
uj=huj/hj;
vj=hvj/hj;
//In every triangles, visit its neighbor, using this loop
for(int n=0; n<3;n++)
{
//using k to get the mapping index of neighbor(nb) element on EtoE
//save in nb
int k = idx*3+ n;
int nb= EtoE[k];
//fill neighbor elements
nx=normx[k];
ny=normy[k];
l=L[k];
hk=h[nb];
uk=u[nb];
vk=v[nb];
huk=hu[nb];
hvk=hv[nb];
uk=huk/hk;
vk=hvk/hk;
if(nb==idx)
{
look=1;
hk=hj;
uk=-uj;
vk=-vj;
huk=-huj;
hvk=-hvj;
}
//Calculate wave speed
// calculate_a(&a_plus, &a_min,sqrt(uj*uj+vj*vj), sqrt(uk*uk+vk*vk),hj,hk);
// calculate_a(&a_plus, &a_min,uj, uk,hj,hk);
calculate_a(&a_plus, &a_min,nx*uj +ny*vj, nx*uk+ny*vk,hj,hk);
//Calculate Height Flux
HUj= huj*nx + hvj*ny;
HUk= huk*nx + hvk*ny;
Flux_h+=l*calculate_H(HUj, HUk, a_plus, a_min, hj, hk);
//Calculate X momentum Flux
HUj = (huj*uj + 0.5*g*hj*hj)*nx;
HUj+= (huj*vj)*ny;
HUk = (huk*uk + 0.5*g*hk*hk)*nx;
HUk+= (huk*vk)*ny;
// Flux_hu+=l*calculate_H(HUj, HUk, a_plus, a_min, huj, isReflectif(nb,idx)?-huk:huk);
Flux_hu+=l*calculate_H(HUj, HUk, a_plus, a_min, huj, huk);
//Calculate Y momentum Flux
HUj = (hvj*uj)*nx;
HUj+= (hvj*vj + 0.5*g*hj*hj)*ny;
HUk = (hvk*uk)*nx;
HUk+= (hvk*vk + 0.5*g*hk*hk)*ny;
// Flux_hv+=l*calculate_H(HUj, HUk, a_plus, a_min, hvj, isReflectif(nb,idx)?-hvk:hvk);
Flux_hv+=l*calculate_H(HUj, HUk, a_plus, a_min, hvj, hvk);
}
h1[idx]=calculate_Unew(hj,Flux_h, dt,A) ;
hu1[idx]=calculate_Unew(huj, Flux_hu,dt,A);
hv1[idx]=calculate_Unew(hvj, Flux_hv,dt,A);
}
for(int idx=0; idx<Nelems;idx++)
{
h[idx]=h1[idx];
hu[idx]=hu1[idx];
hv[idx]=hv1[idx];
u[idx]=hu[idx]*1.0/(h[idx]*1.0);
v[idx]=hv[idx]*1.0/(h[idx]*1.0);
}
}
return cpuSecond()-start_time;
}
