index
int64 0
0
| repo_id
stringclasses 93
values | file_path
stringlengths 15
128
| content
stringlengths 14
7.05M
|
|---|---|---|---|
0 | ALLM | ALLM/CF/driver.cpp | #include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <stdlib.h>
#include <mpi.h>
#include "driver.h"
extern "C"
{
void initmat(mat * Amat){
Amat->iv = NULL;
Amat->jv = NULL;
Amat->vv = NULL;
Amat->m = 0;
Amat->nnz = 0;
}
void driver_mat(mat * inA, mat * outX, parameters * inParams){
printf(" nnz %d \n", inA->nnz);
for(int k =0; k<inA->nnz; ++k){
printf("%d \n", k);
outX->iv[k] = inA->iv[k];
printf("%d \n", k);
printf(" iv %d \n", inA->iv[k]);
outX->jv[k] = inA->jv[k];
outX->vv[k] = inA->vv[k] + inParams->alpha*inA->vv[k];
}
}
void driver_mat_mpi(mat * inA, mat * outX, parameters * inParams){
int rank;
//MPI_Fint fcomm;
//fcomm = inParams->comm;
//MPI_Comm comm;
//comm = MPI_Comm_f2c(fcomm);
if(inParams->fcomm != -1){
(inParams->comm) = MPI_Comm_f2c((inParams->fcomm));
printf("fcomm %d \n ", inParams->fcomm);
}
MPI_Comm_rank(inParams->comm, &rank);
printf(" nnz %d \n", inA->nnz);
for(int k =0; k<inA->nnz; ++k){
printf("%d \n", k);
outX->iv[k] = inA->iv[k];
printf("%d \n", k);
printf(" iv %d \n", inA->iv[k]);
outX->jv[k] = inA->jv[k];
if(k==rank){
outX->vv[k] = rank*inA->vv[k] + rank*inParams->alpha*inA->vv[k];
}
else{
outX->vv[k] = rank;
}
}
}
}
/*int main(){
const int m = 2;
const int nnz = 2;
int * a_i = (int *) malloc(nnz * sizeof(int));
int * a_j = (int *) malloc(nnz * sizeof(int));
double * a_v = (double *) malloc(nnz * sizeof(double));
a_i[0]=0;a_j[0]=0;a_v[0]=1;
a_i[1]=1;a_j[1]=1;a_v[1]=1;
mat A;
initmat(&A);
A.m=m;A.nnz=nnz;
A.iv=a_i;A.jv=a_j;A.vv=a_v;
int * x_i = (int *) malloc(nnz * sizeof(int));
int * x_j = (int *) malloc(nnz * sizeof(int));
double * x_v = (double *) malloc(nnz * sizeof(double));
x_i[0]=0;x_j[0]=0;x_v[0]=0;
x_i[1]=0;x_j[1]=0;x_v[1]=0;
mat X;
initmat(&X);
X.m=m;X.nnz=nnz;
X.iv=x_i;X.jv=x_j;X.vv=x_v;
parameters params;
params.alpha = 2.0;
params.comm = 0;
driver_mat(&A, &X, ¶ms);
printf("A:\n");
for(int k = 0; k < nnz; ++k){ printf("%lf ", a_v[k]); }
printf("\n");
printf("X:\n");
for(int k = 0; k < nnz; ++k){ printf("%lf ", x_v[k]); }
printf("\n");
free(a_i);
free(a_j);
free(a_v);
free(x_i);
free(x_j);
free(x_v);
return 0;
}*/
|
0 | ALLM | ALLM/CF/driver.h | #if defined __cplusplus
using Scalar = double;
using Primary = double;
#else
typedef double Scalar;
typedef double Primary;
#endif
typedef struct{
int * iv;
int * jv;
Scalar * vv;
int m;
int nnz;
//int storage;
//int symmetry;
} mat;
typedef struct{
Scalar alpha;
MPI_Comm comm;
MPI_Fint fcomm;
} parameters;
#if defined __cplusplus
extern "C" {
#endif
void initmat(mat * Amat);
void driver_mat(mat * inA, mat * outX, parameters * inParams);
void driver_mat_mpi(mat * inA, mat * outX, parameters * inParams);
#if defined __cplusplus
}
#endif
|
0 | ALLM | ALLM/C_SUJET1/nbody.c | #include <stdio.h>
#include <math.h>
#include <stdlib.h> // drand48
#include <omp.h>
#define DUMP
struct ParticleType {
float x, y, z;
float vx, vy, vz;
};
void MoveParticles(const int nParticles, struct ParticleType* const particle, const float dt) {
// Loop over particles that experience force
for (int i = 0; i < nParticles; i++) {
// Components of the gravity force on particle i
float Fx = 0, Fy = 0, Fz = 0;
// Loop over particles that exert force
for (int j = 0; j < nParticles; j++) {
// No self interaction
if (i != j) {
// Avoid singularity and interaction with self
const float softening = 1e-20;
// Newton's law of universal gravity
const float dx = particle[j].x - particle[i].x;
const float dy = particle[j].y - particle[i].y;
const float dz = particle[j].z - particle[i].z;
const float drSquared = dx*dx + dy*dy + dz*dz + softening;
const float drPower32 = pow(drSquared, 3.0/2.0);
// Calculate the net force
Fx += dx / drPower32;
Fy += dy / drPower32;
Fz += dz / drPower32;
}
}
// Accelerate particles in response to the gravitational force
particle[i].vx += dt*Fx;
particle[i].vy += dt*Fy;
particle[i].vz += dt*Fz;
}
// Move particles according to their velocities
// O(N) work, so using a serial loop
for (int i = 0 ; i < nParticles; i++) {
particle[i].x += particle[i].vx*dt;
particle[i].y += particle[i].vy*dt;
particle[i].z += particle[i].vz*dt;
}
}
void dump(int iter, int nParticles, struct ParticleType* particle)
{
char filename[64];
snprintf(filename, 64, "output_%d.txt", iter);
FILE *f;
f = fopen(filename, "w+");
int i;
for (i = 0; i < nParticles; i++)
{
fprintf(f, "%e %e %e %e %e %e\n",
particle[i].x, particle[i].y, particle[i].z,
particle[i].vx, particle[i].vy, particle[i].vz);
}
fclose(f);
}
// Initialize random number generator and particles:
void init_rand(int nParticles, struct ParticleType* particle){
srand48(0x2020);
for (int i = 0; i < nParticles; i++)
{
particle[i].x = 2.0*drand48() - 1.0;
particle[i].y = 2.0*drand48() - 1.0;
particle[i].z = 2.0*drand48() - 1.0;
particle[i].vx = 2.0*drand48() - 1.0;
particle[i].vy = 2.0*drand48() - 1.0;
particle[i].vz = 2.0*drand48() - 1.0;
}
}
// Initialize (no random generator) particles
void init_norand(int nParticles, struct ParticleType* particle){
const float a=127.0/nParticles;
for (int i = 0; i < nParticles; i++)
{
particle[i].x = i*a;//2.0*drand48() - 1.0;
particle[i].y = i*a;//2.0*drand48() - 1.0;
particle[i].z = 1.0;//2.0*drand48() - 1.0;
particle[i].vx = 0.5;//2.0*drand48() - 1.0;
particle[i].vy = 0.5;//2.0*drand48() - 1.0;
particle[i].vz = 0.5;//2.0*drand48() - 1.0;
}
}
int main(const int argc, const char** argv)
{
// Problem size and other parameters
const int nParticles = (argc > 1 ? atoi(argv[1]) : 16384);
// Duration of test
const int nSteps = (argc > 2)?atoi(argv[2]):10;
// Particle propagation time step
const float dt = 0.0005f;
struct ParticleType* particle = malloc(nParticles*sizeof(struct ParticleType));
// Initialize random number generator and particles
//init_rand(nParticles, particle);
// Initialize (no random generator) particles
init_norand(nParticles, particle);
// Perform benchmark
printf("\nPropagating %d particles using 1 thread...\n\n",
nParticles
);
double rate = 0, dRate = 0; // Benchmarking data
const int skipSteps = 3; // Skip first iteration (warm-up)
printf("\033[1m%5s %10s %10s %8s\033[0m\n", "Step", "Time, s", "Interact/s", "GFLOP/s"); fflush(stdout);
for (int step = 1; step <= nSteps; step++) {
const double tStart = omp_get_wtime(); // Start timing
MoveParticles(nParticles, particle, dt);
const double tEnd = omp_get_wtime(); // End timing
const float HztoInts = ((float)nParticles)*((float)(nParticles-1)) ;
const float HztoGFLOPs = 20.0*1e-9*((float)(nParticles))*((float)(nParticles-1));
if (step > skipSteps) { // Collect statistics
rate += HztoGFLOPs/(tEnd - tStart);
dRate += HztoGFLOPs*HztoGFLOPs/((tEnd - tStart)*(tEnd-tStart));
}
printf("%5d %10.3e %10.3e %8.1f %s\n",
step, (tEnd-tStart), HztoInts/(tEnd-tStart), HztoGFLOPs/(tEnd-tStart), (step<=skipSteps?"*":""));
fflush(stdout);
#ifdef DUMP
dump(step, nParticles, particle);
#endif
}
rate/=(double)(nSteps-skipSteps);
dRate=sqrt(dRate/(double)(nSteps-skipSteps)-rate*rate);
printf("-----------------------------------------------------\n");
printf("\033[1m%s %4s \033[42m%10.1f +- %.1f GFLOP/s\033[0m\n",
"Average performance:", "", rate, dRate);
printf("-----------------------------------------------------\n");
printf("* - warm-up, not included in average\n\n");
free(particle);
return 0;
}
|
0 | ALLM | ALLM/C_SUJET1/nbody_aos.cu | #include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <math.h>
#include <omp.h>
#include <cuda.h>
#include <cuda_runtime.h>
#include <cuda_profiler_api.h>
#define nPart 16384
#define THREADS_PER_BLOCK 256
#define DUMP
//-------------------------------------------------------------------------------------------------------------------------
//struct ParticleType{
// float x, y, z, vx, vy, vz;
//};
struct ParticleType{
float x[nPart],y[nPart],z[nPart];
float vx[nPart],vy[nPart],vz[nPart];
};
//-------------------------------------------------------------------------------------------------------------------------
//CUDA VERSION:
__global__ void MoveParticles_CUDA(const int nParticles, struct ParticleType* const particle){
// Particle propagation time step
const float dt = 0.0005f;
int i = threadIdx.x + blockIdx.x * blockDim.x;
if(i<nParticles){
float Fx=0.,Fy=0.,Fz=0.;
for(int j = 0; j< nParticles; j++){
//no self interaction:
if(i != j){
//avoid singularity and interaction with self:
const float softening = 1e-20;
//Newton's law of universal gravity:
const float dx = particle->x[j] - particle->x[i];
const float dy = particle->y[j] - particle->y[i];
const float dz = particle->z[j] - particle->z[i];
const float drSquared = dx*dx + dy*dy + dz*dz + softening;
const float drPower32 = pow(drSquared, 3.0/2.0);
//Calculate the net force:
Fx += dx / drPower32;
Fy += dy / drPower32;
Fz += dz / drPower32;
}//fi i!=j
}//j loop
//Accelerate particles in response to the gravitational force:
particle->vx[i] += dt*Fx;
particle->vy[i] += dt*Fy;
particle->vz[i] += dt*Fz;
}
}//fct MoveParticles_CUDA
//-------------------------------------------------------------------------------------------------------------------------
// Initialize random number generator and particles:
void init_rand(int nParticles, struct ParticleType* particle){
srand48(0x2020);
for (int i = 0; i < nParticles; i++)
{
particle->x[i] = 2.0*drand48() - 1.0;
particle->y[i] = 2.0*drand48() - 1.0;
particle->z[i] = 2.0*drand48() - 1.0;
particle->vx[i] = 2.0*drand48() - 1.0;
particle->vy[i] = 2.0*drand48() - 1.0;
particle->vz[i] = 2.0*drand48() - 1.0;
}
}
//-------------------------------------------------------------------------------------------------------------------------
// Initialize (no random generator) particles
void init_norand(int nParticles, struct ParticleType* const particle){
const float a=127.0/nParticles;
for (int i = 0; i < nParticles; i++)
{
particle->x[i] = i*a;//2.0*drand48() - 1.0;
particle->y[i] = i*a;//2.0*drand48() - 1.0;
particle->z[i] = 1.0;//2.0*drand48() - 1.0;
particle->vx[i] = 0.5;//2.0*drand48() - 1.0;
particle->vy[i] = 0.5;//2.0*drand48() - 1.0;
particle->vz[i] = 0.5;//2.0*drand48() - 1.0;
}
}
//-------------------------------------------------------------------------------------------------------------------------
void dump(int iter, int nParticles, struct ParticleType* particle)
{
char filename[64];
snprintf(filename, 64, "output_%d.txt", iter);
FILE *f;
f = fopen(filename, "w+");
int i;
for (i = 0; i < nParticles; i++)
{
fprintf(f, "%e %e %e %e %e %e\n",
particle->x[i], particle->y[i], particle->z[i], particle->vx[i], particle->vy[i], particle->vz[i]);
}
fclose(f);
}
//-------------------------------------------------------------------------------------------------------------------------
int main(const int argc, const char** argv)
{
// Problem size and other parameters
// const int nParticles = (argc > 1 ? atoi(argv[1]) : 16384);
const int nParticles=nPart;
// Duration of test
const int nSteps = (argc > 2)?atoi(argv[2]):10;
// Particle propagation time step
const float ddt = 0.0005f;
//-------------------------------------------------------------------------------------------------------------------------
//DEFINE SIZE:
int SIZE = sizeof(struct ParticleType);
//-------------------------------------------------------------------------------------------------------------------------
//DECLARATION & ALLOC particle ON HOST:
struct ParticleType* particle = (struct ParticleType*) malloc(SIZE);
//-------------------------------------------------------------------------------------------------------------------------
// Initialize random number generator and particles
srand48(0x2020);
//Initialize random number generator and particles
//init_rand(nParticles, particle);
// Initialize (no random generator) particles
init_norand(nParticles, particle);
//-------------------------------------------------------------------------------------------------------------------------
// Perform benchmark
printf("\nPropagating %d particles using %d thread...\n\n",
128 ,nParticles
);
double rate = 0, dRate = 0; // Benchmarking data
const int skipSteps = 3; // Skip first iteration (warm-up)
printf("\033[1m%5s %10s %10s %8s\033[0m\n", "Step", "Time, s", "Interact/s", "GFLOP/s"); fflush(stdout);
//-------------------------------------------------------------------------------------------------------------------------
cudaProfilerStart();
//-------------------------------------------------------------------------------------------------------------------------
struct ParticleType *particle_cuda;
cudaMalloc((void **)&particle_cuda, SIZE);
//-------------------------------------------------------------------------------------------------------------------------
// cudaMemcpy(particle_cuda, particle, SIZE, cudaMemcpyHostToDevice);
//-------------------------------------------------------------------------------------------------------------------------
for (int step = 1; step <= nSteps; step++) {
const double tStart = omp_get_wtime(); // Start timing
cudaMemcpy(particle_cuda, particle, SIZE, cudaMemcpyHostToDevice);
MoveParticles_CUDA<<<nParticles/THREADS_PER_BLOCK,THREADS_PER_BLOCK>>>(nParticles, particle_cuda);
cudaMemcpy(particle, particle_cuda, SIZE, cudaMemcpyDeviceToHost);//need to do?
const double tEnd = omp_get_wtime(); // End timing
// Move particles according to their velocities
// O(N) work, so using a serial loop
for (int i = 0 ; i < nParticles; i++) {
particle->x[i] += particle->vx[i]*ddt;
particle->y[i] += particle->vy[i]*ddt;
particle->z[i] += particle->vz[i]*ddt;
}
const float HztoInts = ((float)nParticles)*((float)(nParticles-1)) ;
const float HztoGFLOPs = 20.0*1e-9*((float)(nParticles))*((float)(nParticles-1));
if (step > skipSteps) { // Collect statistics
rate += HztoGFLOPs/(tEnd - tStart);
dRate += HztoGFLOPs*HztoGFLOPs/((tEnd - tStart)*(tEnd-tStart));
}
printf("%5d %10.3e %10.3e %8.1f %s\n",
step, (tEnd-tStart), HztoInts/(tEnd-tStart), HztoGFLOPs/(tEnd-tStart), (step<=skipSteps?"*":""));
fflush(stdout);
#ifdef DUMP
dump(step, nParticles, particle);
#endif
}
cudaFree(particle_cuda);
//-------------------------------------------------------------------------------------------------------------------------
cudaProfilerStop();
//-------------------------------------------------------------------------------------------------------------------------
rate/=(double)(nSteps-skipSteps);
dRate=sqrt(dRate/(double)(nSteps-skipSteps)-rate*rate);
printf("-----------------------------------------------------\n");
printf("\033[1m%s %4s \033[42m%10.1f +- %.1f GFLOP/s\033[0m\n",
"Average performance:", "", rate, dRate);
printf("-----------------------------------------------------\n");
printf("* - warm-up, not included in average\n\n");
free(particle);
return 0;
}
|
0 | ALLM | ALLM/C_SUJET1/nbody_cuda.cu | #include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <math.h>
#include <omp.h>
#include <cuda.h>
#include <cuda_runtime.h>
#include <cuda_profiler_api.h>
#define THREADS_PER_BLOCK 128
#define DUMP
//-------------------------------------------------------------------------------------------------------------------------
struct ParticleType{
float x, y, z, vx, vy, vz;
};
//-------------------------------------------------------------------------------------------------------------------------
//CUDA VERSION:
__global__ void MoveParticles_CUDA(const int nParticles, struct ParticleType* const particle){
// Particle propagation time step
const float dt = 0.0005f;
float Fx = 0.0, Fy = 0.0, Fz = 0.0;
int i = threadIdx.x + blockIdx.x * blockDim.x;
if(i<nParticles){
for(int j = 0; j< nParticles; j++){
//no self interaction:
if(i != j){
//avoid singularity and interaction with self:
const float softening = 1e-20;
//Newton's law of universal gravity:
const float dx = particle[j].x - particle[i].x;
const float dy = particle[j].y - particle[i].y;
const float dz = particle[j].z - particle[i].z;
const float drSquared = dx*dx + dy*dy + dz*dz + softening;
const float drPower32 = pow(drSquared, 3.0/2.0);
//Calculate the net force:
Fx += dx / drPower32;
Fy += dy / drPower32;
Fz += dz / drPower32;
}//fi i!=j
}//j loop
//Accelerate particles in response to the gravitational force:
particle[i].vx += dt*Fx;
particle[i].vy += dt*Fy;
particle[i].vz += dt*Fz;
}
}//fct MoveParticles_CUDA
//-------------------------------------------------------------------------------------------------------------------------
// Initialize random number generator and particles:
void init_rand(int nParticles, struct ParticleType* particle){
srand48(0x2020);
for (int i = 0; i < nParticles; i++)
{
particle[i].x = 2.0*drand48() - 1.0;
particle[i].y = 2.0*drand48() - 1.0;
particle[i].z = 2.0*drand48() - 1.0;
particle[i].vx = 2.0*drand48() - 1.0;
particle[i].vy = 2.0*drand48() - 1.0;
particle[i].vz = 2.0*drand48() - 1.0;
}
}
//-------------------------------------------------------------------------------------------------------------------------
// Initialize (no random generator) particles
void init_norand(int nParticles, struct ParticleType* particle){
const float a=127.0/nParticles;
for (int i = 0; i < nParticles; i++)
{
particle[i].x = i*a;//2.0*drand48() - 1.0;
particle[i].y = i*a;//2.0*drand48() - 1.0;
particle[i].z = 1.0;//2.0*drand48() - 1.0;
particle[i].vx = 0.5;//2.0*drand48() - 1.0;
particle[i].vy = 0.5;//2.0*drand48() - 1.0;
particle[i].vz = 0.5;//2.0*drand48() - 1.0;
}
}
//-------------------------------------------------------------------------------------------------------------------------
void dump(int iter, int nParticles, struct ParticleType* particle)
{
char filename[64];
snprintf(filename, 64, "output_%d.txt", iter);
FILE *f;
f = fopen(filename, "w+");
int i;
for (i = 0; i < nParticles; i++)
{
fprintf(f, "%e %e %e %e %e %e\n",
particle[i].x, particle[i].y, particle[i].z, particle[i].vx, particle[i].vy, particle[i].vz);
}
fclose(f);
}
//-------------------------------------------------------------------------------------------------------------------------
int main(const int argc, const char** argv)
{
// Problem size and other parameters
const int nParticles = (argc > 1 ? atoi(argv[1]) : 16384);
// Duration of test
const int nSteps = (argc > 2)?atoi(argv[2]):10;
// Particle propagation time step
const float ddt = 0.0005f;
//-------------------------------------------------------------------------------------------------------------------------
//DEFINE SIZE:
int SIZE = nParticles * sizeof(struct ParticleType);
//-------------------------------------------------------------------------------------------------------------------------
//DECLARATION & ALLOC particle ON HOST:
struct ParticleType* particle = (struct ParticleType*) malloc(SIZE);
//-------------------------------------------------------------------------------------------------------------------------
// Initialize random number generator and particles
srand48(0x2020);
// Initialize random number generator and particles
//init_rand(nParticles, particle);
// Initialize (no random generator) particles
init_norand(nParticles, particle);
//-------------------------------------------------------------------------------------------------------------------------
// Perform benchmark
printf("\nPropagating %d particles using 1 thread...\n\n",
nParticles
);
double rate = 0, dRate = 0; // Benchmarking data
const int skipSteps = 3; // Skip first iteration (warm-up)
printf("\033[1m%5s %10s %10s %8s\033[0m\n", "Step", "Time, s", "Interact/s", "GFLOP/s"); fflush(stdout);
//-------------------------------------------------------------------------------------------------------------------------
cudaProfilerStart();
//-------------------------------------------------------------------------------------------------------------------------
struct ParticleType *particle_cuda;
cudaMalloc((void **)&particle_cuda, SIZE);
//-------------------------------------------------------------------------------------------------------------------------
cudaMemcpy(particle_cuda, particle, SIZE, cudaMemcpyHostToDevice);
//-------------------------------------------------------------------------------------------------------------------------
for (int step = 1; step <= nSteps; step++) {
const double tStart = omp_get_wtime(); // Start timing
cudaMemcpy(particle_cuda, particle, SIZE, cudaMemcpyHostToDevice);
MoveParticles_CUDA<<<nParticles/THREADS_PER_BLOCK,THREADS_PER_BLOCK>>>(nParticles, particle_cuda);
cudaMemcpy(particle, particle_cuda, SIZE, cudaMemcpyDeviceToHost);//need to do?
const double tEnd = omp_get_wtime(); // End timing
// Move particles according to their velocities
// O(N) work, so using a serial loop
for (int i = 0 ; i < nParticles; i++) {
particle[i].x += particle[i].vx*ddt;
particle[i].y += particle[i].vy*ddt;
particle[i].z += particle[i].vz*ddt;
}
const float HztoInts = ((float)nParticles)*((float)(nParticles-1)) ;
const float HztoGFLOPs = 20.0*1e-9*((float)(nParticles))*((float)(nParticles-1));
if (step > skipSteps) { // Collect statistics
rate += HztoGFLOPs/(tEnd - tStart);
dRate += HztoGFLOPs*HztoGFLOPs/((tEnd - tStart)*(tEnd-tStart));
}
printf("%5d %10.3e %10.3e %8.1f %s\n",
step, (tEnd-tStart), HztoInts/(tEnd-tStart), HztoGFLOPs/(tEnd-tStart), (step<=skipSteps?"*":""));
fflush(stdout);
#ifdef DUMP
dump(step, nParticles, particle);
#endif
}
cudaFree(particle_cuda);
//-------------------------------------------------------------------------------------------------------------------------
cudaProfilerStop();
//-------------------------------------------------------------------------------------------------------------------------
rate/=(double)(nSteps-skipSteps);
dRate=sqrt(dRate/(double)(nSteps-skipSteps)-rate*rate);
printf("-----------------------------------------------------\n");
printf("\033[1m%s %4s \033[42m%10.1f +- %.1f GFLOP/s\033[0m\n",
"Average performance:", "", rate, dRate);
printf("-----------------------------------------------------\n");
printf("* - warm-up, not included in average\n\n");
free(particle);
return 0;
}
|
0 | ALLM | ALLM/C_SUJET1/nbody_omp.c | #include <stdio.h>
#include <math.h>
#include <stdlib.h> // drand48
#include <omp.h>
#define DUMP
struct ParticleType {
float x, y, z;
float vx, vy, vz;
};
void MoveParticles(const int nParticles, struct ParticleType* const particle, const float dt) {
int i,j;
float Fx,Fy,Fz;
// Loop over particles that experience force
#pragma omp parallel for private(j)
for (i = 0; i < nParticles; i++) {
// Components of the gravity force on particle i
Fx = 0, Fy = 0, Fz = 0;
// Loop over particles that exert force
for (j = 0; j < nParticles; j++) {
// No self interaction
//if (i != j) {
// Avoid singularity and interaction with self
const float softening = 1e-20;
// Newton's law of universal gravity
const float dx = particle[j].x - particle[i].x;
const float dy = particle[j].y - particle[i].y;
const float dz = particle[j].z - particle[i].z;
const float drSquared = dx*dx + dy*dy + dz*dz + softening;
const float drPower32 = pow(drSquared, 3.0/2.0);
// Calculate the net force
Fx += dx / drPower32;
Fy += dy / drPower32;
Fz += dz / drPower32;
//}
}
// Accelerate particles in response to the gravitational force
particle[i].vx += dt*Fx;
particle[i].vy += dt*Fy;
particle[i].vz += dt*Fz;
}
// Move particles according to their velocities
// O(N) work, so using a serial loop
#pragma omp parallel for
for (int i = 0 ; i < nParticles; i++) {
particle[i].x += particle[i].vx*dt;
particle[i].y += particle[i].vy*dt;
particle[i].z += particle[i].vz*dt;
}
}
void dump(int iter, int nParticles, struct ParticleType* particle)
{
char filename[64];
snprintf(filename, 64, "output_%d.txt", iter);
FILE *f;
f = fopen(filename, "w+");
int i;
for (i = 0; i < nParticles; i++)
{
fprintf(f, "%e %e %e %e %e %e\n",
particle[i].x, particle[i].y, particle[i].z,
particle[i].vx, particle[i].vy, particle[i].vz);
}
fclose(f);
}
// Initialize random number generator and particles:
void init_rand(int nParticles, struct ParticleType* particle){
srand48(0x2020);
#pragma omp parallel for
for (int i = 0; i < nParticles; i++)
{
particle[i].x = 2.0*drand48() - 1.0;
particle[i].y = 2.0*drand48() - 1.0;
particle[i].z = 2.0*drand48() - 1.0;
particle[i].vx = 2.0*drand48() - 1.0;
particle[i].vy = 2.0*drand48() - 1.0;
particle[i].vz = 2.0*drand48() - 1.0;
}
}
// Initialize (no random generator) particles
void init_norand(int nParticles, struct ParticleType* particle){
const float a=127.0/nParticles;
#pragma omp parallel for
for (int i = 0; i < nParticles; i++)
{
particle[i].x = i*a;//2.0*drand48() - 1.0;
particle[i].y = i*a;//2.0*drand48() - 1.0;
particle[i].z = 1.0;//2.0*drand48() - 1.0;
particle[i].vx = 0.5;//2.0*drand48() - 1.0;
particle[i].vy = 0.5;//2.0*drand48() - 1.0;
particle[i].vz = 0.5;//2.0*drand48() - 1.0;
}
}
int main(const int argc, const char** argv)
{
// Problem size and other parameters
const int nParticles = (argc > 1 ? atoi(argv[1]) : 16384);
// Duration of test
const int nSteps = (argc > 2)?atoi(argv[2]):10;
// Particle propagation time step
const float dt = 0.0005f;
struct ParticleType* particle = malloc(nParticles*sizeof(struct ParticleType));
// Initialize random number generator and particles
//init_rand(nParticles, particle);
// Initialize (no random generator) particles
init_norand(nParticles, particle);
// Perform benchmark
printf("\nPropagating %d particles using 1 thread...\n\n",
nParticles
);
double rate = 0, dRate = 0; // Benchmarking data
const int skipSteps = 3; // Skip first iteration (warm-up)
printf("\033[1m%5s %10s %10s %8s\033[0m\n", "Step", "Time, s", "Interact/s", "GFLOP/s"); fflush(stdout);
for (int step = 1; step <= nSteps; step++) {
const double tStart = omp_get_wtime(); // Start timing
MoveParticles(nParticles, particle, dt);
const double tEnd = omp_get_wtime(); // End timing
const float HztoInts = ((float)nParticles)*((float)(nParticles-1)) ;
const float HztoGFLOPs = 20.0*1e-9*((float)(nParticles))*((float)(nParticles-1));
if (step > skipSteps) { // Collect statistics
rate += HztoGFLOPs/(tEnd - tStart);
dRate += HztoGFLOPs*HztoGFLOPs/((tEnd - tStart)*(tEnd-tStart));
}
printf("%5d %10.3e %10.3e %8.1f %s\n",
step, (tEnd-tStart), HztoInts/(tEnd-tStart), HztoGFLOPs/(tEnd-tStart), (step<=skipSteps?"*":""));
fflush(stdout);
#ifdef DUMP
dump(step, nParticles, particle);
#endif
}
rate/=(double)(nSteps-skipSteps);
dRate=sqrt(dRate/(double)(nSteps-skipSteps)-rate*rate);
printf("-----------------------------------------------------\n");
printf("\033[1m%s %4s \033[42m%10.1f +- %.1f GFLOP/s\033[0m\n",
"Average performance:", "", rate, dRate);
printf("-----------------------------------------------------\n");
printf("* - warm-up, not included in average\n\n");
free(particle);
return 0;
}
|
0 | ALLM | ALLM/C_SUJET1/openacc.c | #include <stdio.h>
#include <math.h>
#include <stdlib.h> // drand48
#include <omp.h>
#define DUMP
struct ParticleType {
float x, y, z;
float vx, vy, vz;
};
void MoveParticles(const int nParticles, struct ParticleType* const particle, const float dt) {
int i,j;
float Fx,Fy,Fz;
// Loop over particles that experience force
#pragma parallel loop//acc kernels async(2) wait(1)
for (i = 0; i < nParticles; i++) {
// Components of the gravity force on particle i
Fx = 0, Fy = 0, Fz = 0;
// Loop over particles that exert force
//#pragma acc parallel loop independent reduction(+:Fx,Fy,Fz)
for (j = 0; j < nParticles; j++) {
// No self interaction
// Avoid singularity and interaction with self
const float softening = 1e-20;
// Newton's law of universal gravity
const float dx = particle[j].x - particle[i].x;
const float dy = particle[j].y - particle[i].y;
const float dz = particle[j].z - particle[i].z;
const float drSquared = dx*dx + dy*dy + dz*dz + softening;
const float drPower32 = pow(drSquared, 3.0/2.0);
// Calculate the net force
Fx += dx / drPower32;
Fy += dy / drPower32;
Fz += dz / drPower32;
}
// Accelerate particles in response to the gravitational force
particle[i].vx += dt*Fx;
particle[i].vy += dt*Fy;
particle[i].vz += dt*Fz;
}
// Move particles according to their velocities
// O(N) work, so using a serial loop
for (int i = 0 ; i < nParticles; i++) {
particle[i].x += particle[i].vx*dt;
particle[i].y += particle[i].vy*dt;
particle[i].z += particle[i].vz*dt;
}
}
void dump(int iter, int nParticles, struct ParticleType* particle)
{
char filename[64];
snprintf(filename, 64, "output_%d.txt", iter);
FILE *f;
f = fopen(filename, "w+");
int i;
for (i = 0; i < nParticles; i++)
{
fprintf(f, "%e %e %e %e %e %e\n",
particle[i].x, particle[i].y, particle[i].z,
particle[i].vx, particle[i].vy, particle[i].vz);
}
fclose(f);
}
// Initialize random number generator and particles:
void init_rand(int nParticles, struct ParticleType* particle){
srand48(0x2020);
for (int i = 0; i < nParticles; i++)
{
particle[i].x = 2.0*drand48() - 1.0;
particle[i].y = 2.0*drand48() - 1.0;
particle[i].z = 2.0*drand48() - 1.0;
particle[i].vx = 2.0*drand48() - 1.0;
particle[i].vy = 2.0*drand48() - 1.0;
particle[i].vz = 2.0*drand48() - 1.0;
}
}
// Initialize (no random generator) particles
void init_norand(int nParticles, struct ParticleType* particle){
const float a=127.0/nParticles;
for (int i = 0; i < nParticles; i++)
{
particle[i].x = i*a;//2.0*drand48() - 1.0;
particle[i].y = i*a;//2.0*drand48() - 1.0;
particle[i].z = 1.0;//2.0*drand48() - 1.0;
particle[i].vx = 0.5;//2.0*drand48() - 1.0;
particle[i].vy = 0.5;//2.0*drand48() - 1.0;
particle[i].vz = 0.5;//2.0*drand48() - 1.0;
}
}
int main(const int argc, const char** argv)
{
// Problem size and other parameters
const int nParticles = (argc > 1 ? atoi(argv[1]) : 16384);
// Duration of test
const int nSteps = (argc > 2)?atoi(argv[2]):10;
// Particle propagation time step
const float dt = 0.0005f;
struct ParticleType* particle = malloc(nParticles*sizeof(struct ParticleType));
// Initialize random number generator and particles
//init_rand(nParticles, particle);
// Initialize (no random generator) particles
init_norand(nParticles, particle);
// Perform benchmark
printf("\nPropagating %d particles using 1 thread...\n\n",
nParticles
);
double rate = 0, dRate = 0; // Benchmarking data
const int skipSteps = 3; // Skip first iteration (warm-up)
printf("\033[1m%5s %10s %10s %8s\033[0m\n", "Step", "Time, s", "Interact/s", "GFLOP/s"); fflush(stdout);
#pragma acc data copyin(particle[0:nParticles],dt)
for (int step = 1; step <= nSteps; step++) {
const double tStart = omp_get_wtime(); // Start timing
#pragma acc update host(particle[0:nParticles])
MoveParticles(nParticles, particle, dt);
#pragma acc update device(particle[0:nParticles])
const double tEnd = omp_get_wtime(); // End timing
const float HztoInts = ((float)nParticles)*((float)(nParticles-1)) ;
const float HztoGFLOPs = 20.0*1e-9*((float)(nParticles))*((float)(nParticles-1));
if (step > skipSteps) { // Collect statistics
rate += HztoGFLOPs/(tEnd - tStart);
dRate += HztoGFLOPs*HztoGFLOPs/((tEnd - tStart)*(tEnd-tStart));
}
printf("%5d %10.3e %10.3e %8.1f %s\n",
step, (tEnd-tStart), HztoInts/(tEnd-tStart), HztoGFLOPs/(tEnd-tStart), (step<=skipSteps?"*":""));
fflush(stdout);
#ifdef DUMP
dump(step, nParticles, particle);
#endif
}
rate/=(double)(nSteps-skipSteps);
dRate=sqrt(dRate/(double)(nSteps-skipSteps)-rate*rate);
printf("-----------------------------------------------------\n");
printf("\033[1m%s %4s \033[42m%10.1f +- %.1f GFLOP/s\033[0m\n",
"Average performance:", "", rate, dRate);
printf("-----------------------------------------------------\n");
printf("* - warm-up, not included in average\n\n");
free(particle);
}
|
0 | ALLM | ALLM/GOL/RGOL.R | library('foreach')
library('ggplot2')
library('animation')
library('reshape2')
library('anim.plots')
#install.packages("FFmpeg")
#install.ffmpeg()
#oopts = if (.Platform$OS.type == "windows") {
#ani.options(ffmpeg = "ffmpeg/bin/ffmpeg.exe")
#}
#ffmpeg -i animated.gif -movflags faststart -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" video.mp4
#ffmpeg -i GOL.mp4 -r 160 -filter:v "setpts=0.25*PTS" GOL_speed.mp4
# args:
args = commandArgs(trailingOnly=TRUE)
# test if there is at least one argument: if not, return an error
if (length(args)==0) {
stop("At least one argument must be supplied (input file).n", call.=FALSE)
}
rep = paste("./",args[1],sep="")
data = paste(rep,args[2],sep="/")
out = paste(rep,args[1],sep="/")
outmp4 = paste(out,"mp4",sep=".")
outmp4speed = paste(paste(out,"speed",sep="_"),"mp4",sep=".")
outgif = paste(out,"gif",sep=".")
cmdmp4 = paste(paste(paste("ffmpeg -i",outmp4,sep=" "),"-r 8 -filter:v setpts=0.025*PTS",sep=" "),outmp4speed,sep=" ")
cmdgif = paste(paste(paste("ffmpeg -i",outmp4speed,sep=" "),"-vf fps=5,scale=450:-1",sep=" "),outgif,sep=" ")
print(data)
print(out)
print(outmp4)
print(outmp4speed)
print(cmdmp4)
print(outgif)
print(cmdgif)
# Converts the current grid (matrix) to a ggplot2 image
grid_to_ggplot <- function(subgrid) {
subgrid$V <- factor(ifelse(subgrid$V, "Alive", "Dead"))
#print(subgrid)
p <- ggplot(subgrid, aes(x = J, y = I, z = V, color = V))
p <- p + geom_tile(aes(fill = V))
p + scale_fill_manual(values = c("Dead" = "blue", "Alive" = "red"))
}
grid = read.csv(data)
grid2 = subset(grid, grid$T==110)
saveVideo({
for(i in 0:160){
if(i<=110){
subgrid = subset(grid, grid$T==i);print(i)}
else{subgrid = grid2;print(i)}
grid_ggplot <- grid_to_ggplot(subgrid)
print(grid_ggplot)
}
}, video.name = outmp4, clean = TRUE)
#saveVideo({
#for(i in 0:160){
# subgrid = subset(grid, grid$T==i)
# print(i)
# grid_ggplot <- grid_to_ggplot(subgrid)
# print(grid_ggplot)
#}
#}, video.name = outmp4, clean = TRUE)
#system("ffmpeg -i GOL.mp4 -r 8 -filter:v setpts=0.025*PTS GOL_speed.mp4")
system(cmdmp4, intern=TRUE)
#system("ffmpeg -i GOL_speed.mp4 -vf fps=5,scale=450:-1 GOL_speed.gif")
system(cmdgif, intern=TRUE)
|
0 | ALLM | ALLM/GOL/main.cc | #include "GOL.h"
#include <bits/stdc++.h>
#include <cstdio>
// g++ -std=c++17 -pg -g -O0 -Wall ex6v3.cpp -o run
// valgrind --leak-check=yes ./run
// gprof -l run *.out > analysis.txt
using namespace std;
#ifdef CASE
#define GENREP() ((CASE==0)?("Random"):((CASE==1)?("Clown"):((CASE==2)?("Canon"):("Custom"))))
#endif
int main(int argc, char *argv[], char *envp[]){
// Display each command-line argument.
cout << "\nCommand-line arguments:\n";
for( int count = 0; count < argc; count++ ){
cout << " argv[" << count << "] " << argv[count] << "\n";
}
/*for( int i = 0; envp[i]!=NULL; i++ ){
cout << " envp[" << i << "] " << envp[i] << "\n";
}*/
string UserChoice;
string InitFile;
int dimi=100, dimj=90;
if(CASE>2){
UserChoice = argv[1];
if(argv[2] != NULL){InitFile = argv[2];}else{InitFile = "mat.txt";}
}else{UserChoice = GENREP();}
cout<<" CASE "<<GENREP()<<" UserChoice "<<UserChoice<<"\n";
int iterationNB = 160;
GOL game(dimi, dimj, UserChoice, InitFile);
//GOL* game(0);
//game = new GOL(dimi, dimj, UserChoice, InitFile);
game.initialisation();
game.saveSolution(0);
for(int ite = 1; ite<iterationNB+1; ite++){
game.play();
game.saveSolution(ite);
}
//delete game;
//game = 0;
return 0;
}
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/Code_Dirichlet_LAST/main.f90 | !-----------------------------------
! MAIN : PROGRAMME PRINCIPAL
!-----------------------------------
Program main
!-------------modules-----------------!
USE mpi
use mod_parametres
use mod_charge
use mod_comm
use mod_sol
use mod_fonctions
use mod_gradconj
use mod_matsys
!--------------------------------------!
Implicit None
!REAL POUR CONNAITRE LE TEMPS D'EXECUTION TOTAL ET DE CERTAINES SUBROUTINES
REAL(PR) :: TPS1, TPS2, MAX_TPS
REAL(PR) :: MINU, MAXU
REAL(PR) :: RED_MINU, RED_MAXU
REAL(PR) :: RED_SUMC, MAXC, TPSC1, TPSC2
REAL(PR) :: STA, STB, STM
!------------INIT REGION PARA-----------------!
!********* DEBUT REGION PARA:
CALL MPI_INIT(stateinfo) !INITIALISATION DU //LISME
CALL MPI_COMM_RANK(MPI_COMM_WORLD,rang,stateinfo) !ON RECUPERE LES RANGS
!AU SEIN DE L'ENSEMBLE MPI_COMM_WORLD
CALL MPI_COMM_SIZE(MPI_COMM_WORLD,Np,stateinfo) !ET LE NOMBRE DU PROCESSUS
!---------------------------------------------!
!******** READ USERCHOICE FOR CT AND SHARE IT WITH OTHER PROCESS
IF(rang==0)THEN
Print*,"______RESOLUTION DE L'ÉQUATION : DD SCHWARZ ADDITIVES //______"
!---initialisation des variables cas test-------------
Print*,"Donnez le cas test (1,2 ou 3):"
Read*,CT
PRINT*," POUR VISUALISATION ENTREZ 1, SINON 0"
read*,sysmove
END IF
CALL MPI_BCAST(CT,1,MPI_INTEGER,0,MPI_COMM_WORLD,stateinfo)
CALL MPI_BCAST(sysmove,1,MPI_INTEGER,0,MPI_COMM_WORLD,stateinfo)
TPS1=MPI_WTIME()
!******** COMPUTE SOME MATRIX_G DATA & GEO TIME DATA
nnz_g=5*Na_g-2*Nx_g-2*Ny_g !nb d'elt non nul dans la matrice A_g
IF(rang==0)THEN
print*,"Nombre éléments non nuls du domaine A_g non DD ADDITIVE : nnz_g=",nnz_g
print*,'Nombre de ligne Nx_g, colonne Ny_g de A_g',Nx_g,Ny_g
Print*,"Lx=",Lx
Print*,"Ly=",Ly
Print*,"D=",D
Print*," "
Print*,"dx=",dx
Print*,"dy=",dy
Print*,"dt",dt
Print*,"Tfinal=",Tf,"secondes"
Print*," "
print*,"alpha=",alpha
print*,"beta=",beta
print*,"gamma=",gamma
Print*," "
END IF
!******* SET UP ONE TAG FILE NAMED TAG TO i/o:
TAG=10+rang
WRITE(rank,fmt='(1I3)')rang !WATCH OUT IF rang>999
!******* COMPUTE SIZE OF LOCAL DD OVER LOCAL MATRIX A_l SIZE
OPEN(TAG,file='CHARGE/CHARGE'//trim(adjustl(rank))//'.dat')
CALL MODE1(rang, Np, S1, S2, it1, itN)!-->DISTRIBUTION DE LA CHARGE PAR PROCESS
S1_old = S1; S2_old = S2; it1_old = it1; itN_old = itN
WRITE(TAG,*)'AVANT OVERLAP', S1, S2, it1, itN
CALL CHARGE_OVERLAP(Np, rang, S1, S2, it1, itN)!-->MODIFICATION DE LA CHARGE EN FONCTION DE L'OVERLAP
WRITE(TAG,*)'APRES OVERLAP', S1, S2, it1, itN
!SET SIZE OF MATRICES AND INTEGER CONTROL SIZE:
Nx_l = S2 - S1 + 1; Ny_l = Ny_g; Na_l = Nx_l * Ny_l
nnz_l = 5 * Na_l - 2 * Nx_l - 2 * Ny_l
crtl_nnz_l = (Nx_l*Ny_l) + 2 * (Nx_l) * (Ny_l - 1) + 2 * (Nx_l - 1) * (Ny_l)
WRITE(TAG,*)'Nxl,Ny_l,Na_l', Nx_l, Ny_l, Na_l
WRITE(TAG,*)'nnz_l,crtl_nnz_l', nnz_l,crtl_nnz_l
CLOSE(TAG)
!COMPUTE SIZE D,C AND CRTL_L_nnz:
D_rows = Ny_l; D_nnz = D_rows+2*(D_rows-1)
C_rows = Ny_l; C_nnz = C_rows
crtl_L1_nnz = D_nnz+C_nnz
crtl_L2_nnz = (Nx_l-2)*(D_nnz+2*C_nnz)
crtl_L3_nnz = D_nnz+C_nnz
sum_crtl_L_nnz = crtl_L1_nnz+crtl_L2_nnz+crtl_L3_nnz
crtl_L1_nnz_Nxl_EQV_1 = D_nnz
IF(Nx_l > 1)THEN
IF(crtl_nnz_l/=nnz_l .AND. nnz_l/=sum_crtl_L_nnz)THEN
PRINT*,'ERROR,RANG=',rang,'Local Matrix A_l.rows,A_l.cols',Nx_l,Ny_l,nnz_l,&
&'A_l_nnz,crtl_nnz_l,sum_crtl_L_nnz',nnz_l,crtl_nnz_l,sum_crtl_L_nnz
GOTO 9999
END IF
ELSE IF(Nx_l == 1)THEN
IF(crtl_nnz_l/=nnz_l .AND. nnz_l/=crtl_L1_nnz_Nxl_EQV_1)THEN
PRINT*,'ERROR,RANG=',rang,'Local Matrix A_l.rows,A_l.cols',Nx_l,Ny_l,nnz_l,&
&'A_l_nnz,crtl_nnz_l,crtl_L1_nnz_Nxl_EQV_1',nnz_l,crtl_nnz_l,crtl_L1_nnz_Nxl_EQV_1
GOTO 9999
END IF
END IF
!******* COMPUTE CARTESIAN GRID OVER PROCESS i.e CHARGE APPLY TO X,Y,T
IF(Np/=1)THEN
CALL param_para(rang,Np,S1,S2,Ny_l,X,Y,T)
ELSE
CALL param(X,Y,T)
PRINT*,'NBR PROCESS = 1'
END IF
!****** ALLOCATE Uo ET U
ALLOCATE(U(it1:itN),Uo(it1:itN))
Uo=1._PR !-->CI pour le gradient conjugué
U=1._PR !-->vecteur solution initialisé
call WR_U(U,0)!-->SAVE SOL
CALL matsys_v2(nnz_l,Nx_l,Ny_l,AA,IA,JA)!-->on construit A
OPEN(TAG,file='MAT_VIZU/matrice_A_'//trim(adjustl(rank))//'.dat')!-->POUR VISUALISER LES MATRICES
DO i=1,nnz_l
WRITE(TAG,*)AA(i),IA(i),JA(i)
END DO
CLOSE(TAG)
ALLOCATE(F(it1:itN))!-->SECOND MEMBRE:F=Uo+dt*SOURCE_FUNCTION+CL
ALLOCATE(UG(it1-Ny_g:it1-1),UD(itN+1:itN+Ny_g))!-->VECTEURS POUR ECHANGER LES PARTIES IMMERGEES
UG = 0.0_PR; UD = 0.0_PR!-->INITITALISATION
!---boucle principale (résolution systeme) et ecriture a chaque itération---
Print*,"----------DÉBUT DU CALCUL DE LA SOLUTION------------"
Pivot=(Np-mod(Np,2))/2!-->PIVOT DE COMMUNICATION POUR COMM_PTOP_2WAY:
RED_SUMC = 0.0_PR
IF(Np>1)THEN
timeloop:Do i=1,Nt!BOUCLE EN TEMPS
err = 1.0_PR; step = 1; Norm2 = 0.0_PR
!STA = MPI_WTIME()
schwarzloop:DO WHILE(err>err_LIM .OR. step<3)!BOUCLE POUR LA CONVERGENCE DE SCHWARZ
step = step +1
Norm1 = Norm2
call vectsource_FULL(CT,U,UG,UD,S1,S2,X,Y,T(i),F)!CALCUL DU SECOND MEMBRE
call MOD_gradconj_SPARSE(AA,IA,JA,f,Uo,U,res,k,it1,itN)!RESOLUTION DU SYSTEME
!call BICGSTAB(it1,itN,AA,IA,JA,U,F,0.0000000001_PR)
!call MOD_jacobi_SPARSE(AA,IA,JA,F,Uo,U,res,k)
TPSC1 = MPI_WTIME()
call COMM_PTOP(U,UG,UD)!COMMUNICATION DE LA SOLUTION AUX FRONTIERES IMMERGEES
!call COMM_PTOP_2WAY(U,UG,UD)!-->une petite reduction du temps des communications(pour Np>=5)
TPSC2 = MPI_WTIME()
RED_SUMC = RED_SUMC + (TPSC2-TPSC1)
Uo=U !SWAP
if(rang==0)then!CALCUL DE LA NORME 2 SUR LES PARTIES CORRESPONDANT AUX FRONTIERES IMMERGEE DU VECTEURS SOLUTION
C1 = DOT_PRODUCT(U(itN-Ny_l+1:itN),U(itN-Ny_l+1:itN))
else if(rang==Np-1)then
C1 = DOT_PRODUCT(U(it1:it1+Ny_l-1),U(it1:it1+Ny_l-1))
else
C1 = DOT_PRODUCT(U(it1:it1+Ny_l-1),U(it1:it1+Ny_l-1))+DOT_PRODUCT(U(itN-Ny_l+1:itN),U(itN-Ny_l+1:itN))
end if
!POSSIBILITE DE FAIRE CE CALCUL SUR TOUT LE DOMAINE APRES OVERLAP OU BIEN AVANT OVERLAP:
!C1 = DOT_PRODUCT(U(it1:itN),U(it1:itN))
!C1 = DOT_PRODUCT(U(it1_old:itN_old),U(it1_old:itN_old))
Call MPI_ALLREDUCE(C1,Norm2,1,MPI_DOUBLE_PRECISION,MPI_SUM,MPI_COMM_WORLD,stateinfo)
Norm2 = SQRT(Norm2)!CALCUL DE LA NORME 2
err = abs(Norm1-Norm2)!CALCUL DE L'ERREUR
END DO schwarzloop
!STB = MPI_WTIME()
if(mod(i,10)==0)then
print*,'it temps',i
end if
End Do timeloop
!CALL MPI_ALLREDUCE(STB-STA,STM,1,MPI_DOUBLE,MPI_MAX,MPI_COMM_WORLD,stateinfo)
!PRINT*,'STM',STM,'STEP',STEP
ELSE IF(Np==1)THEN
Do i=1,Nt
call vectsource_FULL(CT,U,UG,UD,S1,S2,X,Y,T(i),F)
call MOD_gradconj_SPARSE(AA,IA,JA,f,Uo,U,res,k,it1,itN)
!call MOD_jacobi_SPARSE(AA,IA,JA,F,Uo,U,res,k)
Uo=U !SWAP
if(mod(i,10)==0)then
print*,'it temps',i
end if
End Do
END IF
!SAVE SOL :
call WR_U(U,Nt)
DEALLOCATE(UG,UD)
!WRITE SOL EXACTE:
IF(CT < 3)THEN
call UEXACT(U,CT)
END IF
RED_MINU = minval(U)
RED_MAXU = maxval(U)
!POUR LES TEMPS DE CALCULS:
CALL MPI_ALLREDUCE(RED_MINU,MINU,1,MPI_DOUBLE_PRECISION,MPI_MIN,MPI_COMM_WORLD,stateinfo)
CALL MPI_ALLREDUCE(RED_MAXU,MAXU,1,MPI_DOUBLE_PRECISION,MPI_MAX,MPI_COMM_WORLD,stateinfo)
if(Np>1)then
CALL MPI_ALLREDUCE(RED_SUMC,MAXC,1,MPI_DOUBLE_PRECISION,MPI_MAX,MPI_COMM_WORLD,stateinfo)
end if
DEALLOCATE(U,Uo,X,Y,T,AA,IA,JA,F)
TPS2=MPI_WTIME()
CALL MPI_ALLREDUCE(TPS2-TPS1,MAX_TPS,1,MPI_DOUBLE_PRECISION,MPI_MAX,MPI_COMM_WORLD,stateinfo)
IF(rang==0)THEN
PRINT*,'TEMPS CALCUL=',MAX_TPS,' TEMPS COMM=',MAXC
END IF
CALL MPI_BARRIER(MPI_COMM_WORLD,stateinfo)
IF(crtl_nnz_l == nnz_l)THEN
GOTO 6666
END IF
9999 PRINT*,rang,'GOTO9999crtl_nnz_l /= nnz_l ERROR',crtl_nnz_l,nnz_l
6666 PRINT*,rang,'GOTO6666NEXT INSTRUCTION IS MPI_FINALIZE',crtl_nnz_l,nnz_l
!---ecriture solution finale--------------------------
call CONCAT_VIZU_ONLY_Nt(sysmove,MINU,MAXU)
CALL MPI_FINALIZE(stateinfo)
Print*,"------------------CALCUL TERMINÉ--------------------"
!----------------------------------------------
CONTAINS
Subroutine CONCAT_VIZU(sysmove)
Integer, Intent(INOUT):: sysmove
CHARACTER(LEN=3):: NNT
CHARACTER(LEN=1)::ESPACE
CHARACTER(LEN=20)::NFILE,OUT_FILE
INTEGER::i
!VIZUALISATION SEQUENTIELLE: ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE RANG DIFFERENTS DANS UN FICHIER
IF(rang==0.AND.sysmove==1)THEN
ESPACE=' '
DO i=0,Nt
WRITE(NNT,fmt='(1I3)')i;
NFILE='U_ME*'//'_T'//trim(adjustl(NNT));OUT_FILE='UT_'//trim(adjustl(NNT))//'.dat'
!ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE RANG DIFFERENTS DANS UN FICHIER
CALL system('cat SOL_NUMERIQUE/'//NFILE//' >> SOL_NUMERIQUE/'//OUT_FILE)
CALL system('rm SOL_NUMERIQUE/'//NFILE)
OPEN(20,file='SOL_NUMERIQUE/'//OUT_FILE,position='append')
SELECT CASE(CT)!ICI IL FAUT RAJOUTER LES POINTS AUX COINS DU DOMAINES
CASE(1)
WRITE(20,*)0.0d0,0.0d0,0.0d0;WRITE(20,*)Lx,0.0d0,0.0d0
WRITE(20,*)0.0d0,Ly,0.0d0;WRITE(20,*)Lx,Ly,0.0d0
CASE(2)
WRITE(20,*)0.0d0,0.0d0,1.0d0;WRITE(20,*)Lx,0.0d0,1.0d0+sin(Lx)
WRITE(20,*)0.0d0,Ly,cos(Ly);WRITE(20,*)Lx,Ly,cos(Ly)+sin(Lx)
CASE(3)
WRITE(20,*)0.0d0,0.0d0,0.5d0;WRITE(20,*)Lx,0.0d0,0.5d0!TEMPERATURES IMPOSEES DIFFERENTES, ON MOYENNE:((G+H)/2)
WRITE(20,*)0.0d0,Ly,0.5d0;WRITE(20,*)Lx,Ly,0.5d0
END SELECT
WRITE(20,fmt='(1A1)')ESPACE
WRITE(20,fmt='(1A1)')ESPACE
CLOSE(20)
!ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE TEMPS DIFFERENTS DANS UN FICHIER
CALL system('cat SOL_NUMERIQUE/'//OUT_FILE//' >> SOL_NUMERIQUE/U.dat')
CALL system('rm SOL_NUMERIQUE/'//OUT_FILE)
END DO
!A LA FIN, IL RESTE UN FICHIER OU LA SOLUTION EN TEMPS EST SOUS FORME D'INDEX GNUPLOT
!ON APPELLE LA SUBROUTIEN DE VISUALISATION:
CALL VIZU_SOL_NUM(CT)
END IF
End Subroutine CONCAT_VIZU
Subroutine CONCAT_VIZU_ONLY_Nt(sysmove,MINU,MAXU)
Integer, Intent(INOUT):: sysmove
REAL(PR), Intent(IN) :: MINU, MAXU
CHARACTER(LEN=3):: NNT
CHARACTER(LEN=1)::ESPACE
CHARACTER(LEN=20)::NFILE,OUT_FILE
INTEGER::i
!VIZUALISATION SEQUENTIELLE: ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE RANG DIFFERENTS DANS UN FICHIER
IF(rang==0.AND.sysmove==1)THEN
ESPACE=' '
DO i=Nt,Nt
WRITE(NNT,fmt='(1I3)')i;
NFILE='U_ME*'//'_T'//trim(adjustl(NNT));OUT_FILE='UT_'//trim(adjustl(NNT))//'.dat'
!ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE RANG DIFFERENTS DANS UN FICHIER
CALL system('cat SOL_NUMERIQUE/'//NFILE//' >> SOL_NUMERIQUE/'//OUT_FILE)
CALL system('rm SOL_NUMERIQUE/'//NFILE)
OPEN(20,file='SOL_NUMERIQUE/'//OUT_FILE,position='append')
SELECT CASE(CT)!ICI IL FAUT RAJOUTER LES POINTS AUX COINS DU DOMAINES
CASE(1)
WRITE(20,*)0.0d0,0.0d0,0.0d0;WRITE(20,*)Lx,0.0d0,0.0d0
WRITE(20,*)0.0d0,Ly,0.0d0;WRITE(20,*)Lx,Ly,0.0d0
CASE(2)
WRITE(20,*)0.0d0,0.0d0,1.0d0;WRITE(20,*)Lx,0.0d0,1.0d0+sin(Lx)
WRITE(20,*)0.0d0,Ly,cos(Ly);WRITE(20,*)Lx,Ly,cos(Ly)+sin(Lx)
CASE(3)
WRITE(20,*)0.0d0,0.0d0,0.5d0;WRITE(20,*)Lx,0.0d0,0.5d0!TEMPERATURES IMPOSEES DIFFERENTES, ON MOYENNE:((G+H)/2)
WRITE(20,*)0.0d0,Ly,0.5d0;WRITE(20,*)Lx,Ly,0.5d0
END SELECT
WRITE(20,fmt='(1A1)')ESPACE
WRITE(20,fmt='(1A1)')ESPACE
CLOSE(20)
!ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE TEMPS DIFFERENTS DANS UN FICHIER
CALL system('cat SOL_NUMERIQUE/'//OUT_FILE//' >> SOL_NUMERIQUE/U.dat')
CALL system('rm SOL_NUMERIQUE/'//OUT_FILE)
END DO
!A LA FIN, IL RESTE UN FICHIER OU LA SOLUTION EN TEMPS EST SOUS FORME D'INDEX GNUPLOT
!ON APPELLE LA SUBROUTIEN DE VISUALISATION:
!CALL VIZU_SOL_NUM(CT)
CALL VIZU_SOL_NUM_ONLY_Nt(CT,MINU,MAXU)
END IF
End Subroutine CONCAT_VIZU_ONLY_Nt
End Program main
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/Code_Dirichlet_LAST/mod_charge.f90 | module mod_charge
use mod_parametres
Implicit None
CONTAINS
!**************************
!^ y Ny
!|
!|
!|
!1---------> x Nx
!*************************
!SE BASE SUR LA CHARGE EN X POUR CALCULER LA CHARGE TOTALE(GLOBALE)
!INDUIT POUR MOD(DIM,Np)/=0 UNE DIFFERENCE DE CHARGE = A Ny ENTRE 2 PROCS
!UTILISABLE POUR Np<=INTER_X
Subroutine MODE1(rang, Np, S1, S2, it1, itN)
Integer, Intent(IN) :: rang, Np
Integer, Intent(OUT) :: S1, S2,it1, itN
!CHARGE EN X :
CALL CHARGE_X(rang, Np, S1, S2)
!CHARGE TOT :
CALL CHARGE_TOT(S1, S2, it1, itN)
End Subroutine MODE1
!REPARTITION CLASSIQUE DE LA CHARGE EN X
Subroutine CHARGE_X(rang, Np, S1,S2)
Integer, Intent(IN) :: rang, Np
Integer, Intent(OUT) :: S1, S2
REAL :: CO_RE !COEFFICIANT DE REPARTITION
IF(Np == 1)THEN
S1 = 1; S2 = Nx_g
ELSE
CO_RE=(Nx_g)/(Np)
If(rang < mod(Nx_g,Np))Then
S1 = rang*(CO_RE+1) + 1; S2 = (rang+1) * (CO_RE+1)
Else
S1 = 1 + mod(Nx_g,Np) + rang*CO_RE; S2 = S1+CO_RE-1
End If
END IF
End Subroutine CHARGE_X
!CHARGE TOTALE SUR LA NUMEROTATION GLOBALE
Subroutine CHARGE_TOT(S1, S2, it1, itN)
Integer, Intent(IN) :: S1, S2
Integer, Intent(OUT) :: it1, itN
it1 = (S1-1)*Ny_g+1; itN = S2*Ny_g
End Subroutine CHARGE_TOT
!RE-COMPUTE CHARGE WITH OVERLAP
Subroutine CHARGE_OVERLAP(Np, rang, S1, S2, it1, itN)
Implicit None
Integer, Intent(IN) ::Np, rang
Integer, Intent(INOUT) ::S1, S2, it1, itN
!Le (-1) sur overlap pour retirer la frontiere
!immergée qui passe en CL
!WE PUT A Ny_g BECAUSE Ny_l == Ny_g and Ny_l is defined after this subroutine
!Also Because IT'S a 1D DD
!IF WE WANT TO SET UP A 2D DD I WILL NEED DO REPLACE Ny_g BY Ny_l
!AND MAKE OTHER MODIFICATION
IF(rang == 0)THEN
S2 = S2 + (overlap-1)
itN = itN + (overlap-1) * Ny_g
ELSE IF(rang == Np-1)THEN
S1 = S1 - (overlap-1)
it1 = it1 - (overlap-1) * Ny_g
ELSE
S1 = S1 - (overlap-1)
S2 = S2 + (overlap-1)
it1 = it1 - (overlap-1) * Ny_g
itN = itN + (overlap-1) * Ny_g
END IF
End Subroutine CHARGE_OVERLAP
end module mod_charge
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/Code_Dirichlet_LAST/mod_comm.f90 | module mod_comm
use mpi
use mod_parametres
Implicit None
CONTAINS
! UG et UD les parties du vecteur solution U Correspondant à/aux frontière(s)
! immergée(s).
Subroutine COMM_PTOP(U,UG,UD)
Real(PR), DImension(it1:itN), Intent(IN):: U
Real(PR), DImension(it1-Ny_g:it1-1), Intent(INOUT):: UG
Real(PR), DImension(itN+1:itN+Ny_g), Intent(INOUT):: UD
Integer:: A, B, C, D, iD1, iD2, iG1, iG2
B = itN - 2*(overlap-1)*Ny_g; A = B - (Ny_g-1)
C = it1 +2*(overlap-1)*Ny_g; D = C + (Ny_g-1)
iD1 = itN + 1; iD2 = itN + Ny_g
iG1 = it1 - Ny_g; iG2 = it1 -1
IF(rang == 0)THEN ! rang tag channel
CALL MPI_SEND(U(A:B),Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang+1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UD(iD1:iD2),Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang,MPI_COMM_WORLD,status,stateinfo)
ELSE IF(rang > 0 .AND. rang<Np-1)THEN
CALL MPI_RECV(UG(iG1:iG2),Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang,MPI_COMM_WORLD,status,stateinfo)
CALL MPI_SEND(U(C:D),Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang-1,MPI_COMM_WORLD,stateinfo)
CALL MPI_SEND(U(A:B),Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang+1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UD(iD1:iD2),Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang,MPI_COMM_WORLD,status,stateinfo)
ELSE IF(rang == Np-1)THEN
CALL MPI_RECV(UG(iG1:iG2),Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang,MPI_COMM_WORLD,status,stateinfo)
CALL MPI_SEND(U(C:D),Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang-1,MPI_COMM_WORLD,stateinfo)
END IF
End Subroutine COMM_PTOP
Subroutine COMM_PTOP_2WAY(U,UG,UD)
Real(PR), DImension(it1:itN), Intent(IN):: U
Real(PR), DImension(it1-Ny_g:it1-1), Intent(INOUT):: UG
Real(PR), DImension(itN+1:itN+Ny_g), Intent(INOUT):: UD
Integer:: A, B, C, D, iD1, iD2, iG1, iG2
B = itN - 2*(overlap-1)*Ny_g; A = B - (Ny_g-1)
C = it1 +2*(overlap-1)*Ny_g; D = C + (Ny_g-1)
iD1 = itN + 1; iD2 = itN + Ny_g
iG1 = it1 - Ny_g; iG2 = it1 -1
IF(rang == 0)THEN ! rang tag channel
CALL MPI_SEND(U(A:B),Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang+1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UD(iD1:iD2),Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang,MPI_COMM_WORLD,status,stateinfo)
ELSE IF(rang > 0 .AND. rang<Pivot)THEN
CALL MPI_RECV(UG(iG1:iG2),Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang,MPI_COMM_WORLD,status,stateinfo)
CALL MPI_SEND(U(C:D),Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang-1,MPI_COMM_WORLD,stateinfo)
CALL MPI_SEND(U(A:B),Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang+1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UD(iD1:iD2),Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang,MPI_COMM_WORLD,status,stateinfo)
ELSE IF(rang >= Pivot .AND. rang < Np-1)THEN
CALL MPI_RECV(UD(iD1:iD2),Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang,MPI_COMM_WORLD,status,stateinfo)
CALL MPI_SEND(U(A:B),Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang+1,MPI_COMM_WORLD,stateinfo)
CALL MPI_SEND(U(C:D),Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang-1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UG(iG1:iG2),Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang,MPI_COMM_WORLD,status,stateinfo)
ELSE IF(rang == Np-1)THEN
CALL MPI_SEND(U(C:D),Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang-1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UG(iG1:iG2),Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang,MPI_COMM_WORLD,status,stateinfo)
END IF
End Subroutine COMM_PTOP_2WAY
end module mod_comm
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/Code_Dirichlet_LAST/mod_fonctions.f90 | !---------------------------------------------
! CE MODULE CONTIENT LES FONCTIONS
! DES TERMES SOURCES DE L'EQUATION
!---------------------------------------------
Module mod_fonctions
!---modules-------------------
use mod_parametres
!-----------------------------
Implicit None
Contains
!CT --> tag pour moduler les fct suivant le CAS test
!(x,y,t) --> coordonnees espace et le temps
!---fonction f premier exemple(terme source)---
Real(PR) Function f1(CT,x,y,t)
Integer, Intent(In) :: CT
Real(PR), Intent(In) :: x, y, t
f1 = 0.0_PR
If ( CT == 1 ) Then
f1 = 2._PR * (y*(1._PR-y)+x*(1._PR-x))
Else IF ( CT == 2 ) Then
f1 = sin(x) + cos(y)
Else If ( CT == 3 ) Then
f1 = exp(-((x-(Lx/2._PR))**2._PR)) * exp(-((y-(Ly/2._PR))**2._PR))&
*cos((pi/2._PR)*t)
End If
End Function f1
!----------------------------------------------
!---fonction g premier exemple( bords haut/bas)-Conditions limites
Real(PR) Function g1(CT,x,y,t)
Integer, Intent(In) :: CT
Real(PR), Intent(In) :: x,y,t
g1 = 0.0_PR
If ( CT == 1 ) Then
g1 = 0._PR
Else IF ( CT == 2 ) Then
g1 = sin(x) + cos(y)
Else If ( CT == 3 ) Then
g1 = 0._PR
End If
End Function g1
!----------------------------------------------
!---function h premier exemple(bord gauche/droite)-Condition Limites
Real(PR) Function h1(CT,x,y,t)
Integer, Intent(In) :: CT
Real(PR), Intent(In) :: x,y,t
h1 = 0.0_PR
If ( CT == 1 ) Then
h1 = 0._PR
Else IF ( CT == 2 ) Then
h1 = sin(x) + cos(y)
Else If ( CT == 3 ) Then
h1 = 1._PR
End If
End Function h1
!---Fonctions donnant les vecteurs Xi,Yj,Tn---------------
!Pour discretiser espace et le temps:
!verision sequentiel
Subroutine param(X,Y,T)
Implicit None
!---variables-------------------------
real(PR), Dimension(:), Allocatable, Intent(InOut) :: X
real(PR), Dimension(:), Allocatable, Intent(InOut) :: Y
real(PR), Dimension(:), Allocatable, Intent(InOut) :: T
Integer :: i
!-------------------------------------
ALLOCATE(Y(0:Ny_g+1),T(0:Nt+1),X(0:Nx_g+1))
Do i=0,Ny_g+1
Y(i)=i*dy
End Do
Do i=0,Nt+1
T(i)=i*dt
End Do
DO i=0,Nx_g+1
X(i)=i*dx
END DO
LBX = lbound(X,1)
UBX = ubound(X,1)
End Subroutine param
!version parallele:
Subroutine param_para(rang,Np,S1,S2,Ny_l,X,Y,T)
Implicit None
!---variables-------------------------
Integer, Intent(IN) :: rang, Np, S1, S2, Ny_l
real(PR), Dimension(:), Allocatable, Intent(InOut) :: X
real(PR), Dimension(:), Allocatable, Intent(InOut) :: Y
real(PR), Dimension(:), Allocatable, Intent(InOut) :: T
Integer :: i
!-------------------------------------
ALLOCATE(Y(0:Ny_l+1),T(0:Nt+1))
Do i=0,Ny_l+1
Y(i)=i*dy
End Do
Do i=0,Nt+1
T(i)=i*dt
End Do
IF(rang == 0)THEN
ALLOCATE(X(S1-1:S2))
Do i=S1-1,S2
X(i)=i*dx
End Do
ELSE IF(rang == Np-1)THEN
ALLOCATE(X(S1:S2+1))
DO i=S1,S2+1
X(i)=i*dx
END DO
ELSE
ALLOCATE(X(S1:S2))
DO i=S1,S2
X(i)=i*dx
END DO
END IF
LBX = lbound(X,1)
UBX = ubound(X,1)
End Subroutine param_para
!-------------------------------------------------------------
End Module mod_fonctions
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/Code_Dirichlet_LAST/mod_gradconj.f90 | !-----------------------------------------
! CE MODULE CONTIENT LE GRADIENT CONJUGUÉ
! EN PLEIN ET EN CREUX (FORMAT COORDONNES)
!-----------------------------------------
Module mod_gradconj
!---modules----------------
use mod_parametres
use mod_fonctions
!--------------------------
Implicit None
Contains
!---GRADIENT CONJUGUÉ POUR UNE MATRICE A PLEINE---------
Subroutine gradconj(A,b,x0,x,beta,k,n)
!---variables------------------------------------
Integer, Intent(In) :: n !taille vecteur solution (=taille de la matrice carrée)
Real(PR), Dimension(:,:), Intent(In) :: A !matrice à inverser
Real(PR), Dimension(:), Intent(In) :: b,x0 ! b second membre, x0 CI
Real(PR), Dimension(:), Intent(Out) :: x !solution finale
Real(PR), Intent(Out) :: beta !norme du résidu
Real(PR), Dimension(:), Allocatable :: p,z,r1,r2
Real(PR) :: alpha,gamma,eps
Integer, Intent(Out) :: k !nb d'itération pr convergence
Integer :: kmax
!-------------------------------------------------
eps=0.01_PR
kmax=150
Allocate(p(n),z(n),r1(n),r2(n))
r1=b-matmul(A,x0)
p=r1
beta=sqrt(sum(r1*r1))
k=0
Do While (beta>eps .and. k<=kmax)
z=matmul(A,p)
alpha=dot_product(r1,r1)/dot_product(z,p)
x=x+alpha*p
r2=r1-alpha*z
gamma=dot_product(r2,r2)/dot_product(r1,r1)
p=r2+gamma*p
beta=sqrt(sum(r1*r1))
k=k+1
r1=r2
End Do
If (k>kmax) then
Print*,"Tolérance non atteinte:",beta
End If
Deallocate(p,z,r1,r2)
End Subroutine gradconj
!----------------------------------------------------
!---GRADIENT CONJUGUÉ POUR MATRICE CREUSE AU FORMAT COORDONNÉES-----
!---A PARALLELISER : PRODUIT MATRICE/VECTEUR + PRODUIT SCALAIRE
Subroutine gradconj_SPARSE(AA,IA,JA,F,x0,x,b,k,n)
Implicit None
!---variables ---------------------------------------
Integer, Intent(In) :: n !taille vecteur solution
Real(PR), Dimension(:), Intent(In) :: AA
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(:), Intent(In) :: f,x0 !f=vect source , x0=CI
Real(PR), Dimension(:), Intent(InOut) :: x !solution finale
Real(PR), Intent(Out) :: b !norme du résidu
Real(PR), Dimension(:), Allocatable :: p,z,r1,r2
Real(PR) :: a,g,eps
Integer, Intent(Out) :: k !nb d'itérations pour convergence
Integer :: kmax !nb d'itérations max
!-----------------------------------------------------
eps=0.01_PR
kmax=1500
Allocate(p(n),z(n),r1(n),r2(n))
!---paralléliser------------------------
r1=f-MatVecSPARSE(AA,IA,JA,x0)
!-------------------------------------
p=r1
b=sqrt(sum(r1*r1))
k=0
Do While (b>eps .and. k<=kmax)
!---paralléliser------------------
z=MatVecSPARSE(AA,IA,JA,p)
!---------------------------------
a=dot_product(r1,r1)/dot_product(z,p)
x=x+a*p
r2=r1-a*z
g=dot_product(r2,r2)/dot_product(r1,r1)
p=r2+g*p
b=sqrt(sum(r1*r1))
k=k+1
r1=r2
End Do
If (k>kmax) then
Print*,"Tolérance non atteinte:",b
End If
Deallocate(p,z,r1,r2)
End Subroutine gradconj_SPARSE
!--------------------------------------------------------------
!---FONCTION PRODUIT MATxVEC EN SPARSE-------------------------
Function MatVecSPARSE(AA,IA,JA,x) Result(y)
!Produit MatriceSPARSE.vecteur plein (x) retourne vecteur plein(y)
!---variables------------------------------------------
Real(PR), Dimension(:), Intent(In) :: AA,x
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(Size(x)) :: y
Integer :: i,n,nnz
!--------------------------------------------------------
n=Size(x,1)
nnz=Size(AA,1)
y(1:n)=0._PR
Do i=1,nnz
if (IA(i)==0) then
print*,"element IA nul pour i =",i
end if
y(IA(i))=y(IA(i))+AA(i)*x(JA(i))
End Do
End Function MatVecSPARSE
!---------------------------------------------------------------
!GC COO FORMAT BUILD FOR global numerotation over x
Subroutine MOD_gradconj_SPARSE(AA,IA,JA,f,x0,x,b,k,it1,itN)
Implicit None
!---variables ---------------------------------------
Integer, Intent(In) :: it1,itN !taille vecteur solution
Real(PR), Dimension(:), Intent(In) :: AA
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(it1:itN), Intent(In) :: f,x0 !f=vect source , x0=CI
Real(PR), Dimension(it1:itN), Intent(InOut) :: x !solution finale
Real(PR), Intent(Out) :: b !norme du résidu
Real(PR), Dimension(:), Allocatable :: p,z,r1,r2
Real(PR) :: a,g,eps
Integer, Intent(Out) :: k !nb d'itérations pour convergence
Integer :: kmax !nb d'itérations max
!-----------------------------------------------------
eps=0.0000000001_PR
kmax=2*Na_l!1500
Allocate(p(it1:itN),z(it1:itN),r1(it1:itN),r2(it1:itN))
!---paralléliser------------------------
r1=f-MOD_MatVecSPARSE(AA,IA,JA,x0,it1,itN)
!-------------------------------------
p=r1
b=sqrt(sum(r1*r1))
k=0
Do While (b>eps .and. k<=kmax)
!---paralléliser------------------
z=MOD_MatVecSPARSE(AA,IA,JA,p,it1,itN)
!---------------------------------
a=dot_product(r1,r1)/dot_product(z,p)
x=x+a*p
r2=r1-a*z
g=dot_product(r2,r2)/dot_product(r1,r1)
p=r2+g*p
b=sqrt(sum(r1*r1))
k=k+1
r1=r2
!PRINT*,'k,b',k,b
End Do
If (k>kmax) then
Print*,"Tolérance non atteinte:",b
End If
Deallocate(p,z,r1,r2)
End Subroutine MOD_gradconj_SPARSE
!--------------------------------------------------------------
!---FONCTION PRODUIT MATxVEC EN SPARSE-------------------------
Function MOD_MatVecSPARSE(AA,IA,JA,x,it1,itN) Result(y)
!Produit MatriceSPARSE.vecteur plein (x) retourne vecteur plein(y)
!---variables------------------------------------------
INTEGER,INTENT(IN)::it1,itN
Real(PR), Dimension(:), Intent(In) :: AA
Real(PR), Dimension(it1:itN), Intent(In) ::x
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(it1:itN) :: y
Integer :: i,n,nnz,val
!--------------------------------------------------------
n=Size(x,1)
!PRINT*,'***',n,itN-it1+1
nnz=Size(AA,1)
y(it1:itN)=0._PR
val=(it1-1)
Do i=1,nnz
if (IA(i)==0) then
print*,"element IA nul pour i =",i
end if
!PRINT*,i,IA(i),val+IA(i),JA(i),val+JA(i),x(val+JA(i))
y(val+IA(i))=y(val+IA(i))+AA(i)*x(val+JA(i))
End Do
End Function MOD_MatVecSPARSE
!---------------------------------------------------------------
Subroutine MOD_jacobi_SPARSE(AA,IA,JA,F,x0,x,resnorm,k)
!-----variables---------------------
Real(PR), Dimension(nnz_l), Intent(In) :: AA
Integer, Dimension(nnz_l), Intent(In) :: IA,JA
Real(PR), Dimension(it1:itN), Intent(InOut) :: F,x0 !f=vect source , x0=CI
Real(PR), Dimension(it1:itN), Intent(InOut) :: x !solution finale
Real(PR), Intent(Out) :: resnorm !norme du résidu
Real(PR), Dimension(:), Allocatable :: r
Real(PR) :: eps,somme
Integer, Intent(InOut) :: k !nb d'itérations pour convergence
Integer :: kmax,pp,val,ii,borne !nb d'itérations max
ALLOCATE(r(it1:itN))
borne=nnz_l+1
x=x0
eps = 0.0000000001_PR
kmax = 2*Na_l*Na_l
r = F-MOD_MatVecSPARSE(AA,IA,JA,x0,it1,itN) !résidu initial
resnorm = sqrt(sum(r*r)) !norme 2 du résidu
k = 0 !initialisation itération
boucle_resolution: Do While ((resnorm>eps) .and. (k<kmax))
k=k+1
!on calcule xi^k+1=(1/aii)*(bi-sum(j=1,n;j/=i)aij*xj^k)
x0=0._PR
pp=1;val=it1-1
boucle_xi: Do ii=1,Na_l
!calcul de la somme des aij*xj^k pour j=1,n;j/=i
somme = 0.0_PR;
!!$ if(rang==0)then
!!$ PRINT*,'ii,pp,k,nnz_l,ubound IA',ii,pp,k,nnz_l,ubound(IA,1),nnz_l+1
!!$ end if
DO WHILE((pp<borne) .AND. (ii==IA(pp)))
IF (IA(pp) /= JA(pp)) THEN
somme= somme + x(val+JA(pp)) * AA(pp)
END IF
!!$ if(rang==0)then
!!$ PRINT*,'ii,pp,IA(pp),JA(pp),AA(pp),x(JA(pp))',ii,pp,IA(pp),JA(pp),AA(pp),x(val+JA(pp))
!!$ end if
pp=pp+1
!PRINT*,'pp',pp
if(pp==borne)then !because the do while check both pp<borne and ii==IA(pp),maybe due to makefile
! he should break when pp>=borne and don't check ii==IA(pp)
GOTO 7777
end if
END DO
!calcul du nouveau xi
7777 x0(val+ii)=(1._PR/alpha)*(F(val+ii)-somme)
x0(val+ii)=(1._PR/alpha)*(F(val+ii)-somme)!;print*,'t',rang
End Do boucle_xi
x=x0
!on calcule le nouveau résidu
r = F - MOD_MatVecSPARSE(AA,IA,JA,x,it1,itN)
! calcul de la norme 2 du résidu
resnorm = sqrt(sum(r*r))
!print*,resnorm,k
End Do boucle_resolution
If (k>kmax) then
Print*,"Tolérance non atteinte:",resnorm
End If
DEALLOCATE(r)
End Subroutine MOD_jacobi_SPARSE
Subroutine BICGSTAB(it1,itN,AA,IA,JA,x,b,eps)
Implicit None
Integer, intent(IN) :: it1, itN
Real(PR), Dimension(:), intent(IN) :: AA
Integer, Dimension(:), intent(IN) :: IA, JA
Real(PR), Dimension(:), intent(INOUT) :: x
Real(PR), Dimension(:), intent(IN) :: b
Real(PR), intent(IN) :: eps
Real(PR), Dimension(it1:itN) :: r0, v, p ,r, h, s, t
Real(PR) :: rho_i, rho_im1, alpha_CG, w, beta_cg
Real(PR) :: omega
Real(PR) :: beta
Integer :: k, kmax
kmax = 2*Na_l*Na_l
omega = 1.0_PR
r0 = b -MOD_MatVecSPARSE(AA, IA, JA, x, it1, itN)
r = r0
rho_im1 = 1.0_PR; alpha_CG = 1.0_PR; w = 1.0_PR
v = 0.0_PR; p = 0.0_PR
k = 0
beta = SQRT(DOT_PRODUCT(r0,r0))
DO WHILE(beta>eps.AND.k<kmax)
rho_i = DOT_PRODUCT(r0,r)
beta_CG = (rho_i/rho_im1)*(alpha_CG/w)
p = r + beta_CG*(p-v*w)
v = MOD_MatVecSPARSE(AA,IA,JA,p,it1,itN)
alpha_CG = rho_i/DOT_PRODUCT(r0,v)
h = x + p*alpha_CG
s = r - v*alpha_CG
t = MOD_MatVecSPARSE(AA,IA,JA,s,it1,itN)
w = DOT_PRODUCT(t,s)/DOT_PRODUCT(t,t)
x = h + s*w
r = s - t*w
beta = DOT_PRODUCT(r,r)
rho_im1 = rho_i
k = k+1
END DO
!PRINT*,'kmax,k',kmax,k
End Subroutine BICGSTAB
End Module mod_gradconj
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/Code_Dirichlet_LAST/mod_matsys.f90 | !----------------------------------------------------
! CE MODULE CONTIENT LA CONSTRUCTION DE LA MATRICE A
! ET LE VECTEUR SOURCE F
!----------------------------------------------------
Module mod_matsys
!---modules-------------------
Use mod_parametres
Use mod_fonctions
Use mod_gradconj
!-----------------------------
Implicit None
Contains
!--- SUBROUTINE QUI CONSTRUIT LA MATRICE A : UN SEUL APPEL ----------------------
!--- COO FORMAT: AA contient elements non nuls, IA et JA numéro de la ligne, colonne
!--- de element non nul.
Subroutine matsys_v2(nnz,Nx_l,Ny_l,AA,IA,JA)
Integer, Intent(IN) ::nnz,Nx_l,Ny_l
Real(PR), Dimension(:), Allocatable, Intent(Out) :: AA
Integer, Dimension(:), Allocatable, Intent(Out) :: IA,JA
Integer :: k, mul2, d1, d2, mul1
k = 1; mul2 = Nx_l*Ny_l; mul1 = Ny_l*(Nx_l-1)+1
ALLOCATE(AA(nnz),IA(nnz),JA(nnz))
!L1-----------------------------------------------------------
IF(Nx_l > 1)THEN
CALL L1(Ny_l,nnz,k,AA,IA,JA)
!CRTL nnz_L1
IF(k /= crtl_L1_nnz)THEN
PRINT*,'ERROR L1_nnz','RANG',rang,'k_L1',k,'/=','crtl_L1_nnz',crtl_L1_nnz
AA=0._PR;IA=0;JA=0
END IF
ELSE IF(Nx_l == 1)THEN
CALL L1_NXL_eqv_1(Ny_l,nnz,k,AA,IA,JA)
IF(k /= crtl_L1_nnz_Nxl_EQV_1)THEN
PRINT*,'ERROR L1_nnz','RANG',rang,'k_L1',k,'/=','crtl_L1_nnz_Nxl_EQV_1',crtl_L1_nnz_Nxl_EQV_1
AA=0._PR;IA=0;JA=0
END IF
END IF
!L2-----------------------------------------------------------
IF(Nx_l>2)THEN
d1 = Ny_l+1; d2 = 2*Ny_l
CALL L2(Nx_l,Ny_l,nnz,d1,d2,k,AA,IA,JA)
IF(k /= crtl_L1_nnz + crtl_L2_nnz)THEN
PRINT*,'ERROR L2_nnz','RANG',rang,'k_L2',k-crtl_L1_nnz,'/=','crtl_L2_nnz',crtl_L2_nnz
AA=0._PR;IA=0;JA=0
END IF
END IF
!L3-----------------------------------------------------------
IF(Nx_l>1)THEN
CALL L3(mul1,mul2,Ny_l,nnz,k,AA,IA,JA)
PRINT*,'rang',rang,'k',k,'FIN L3'
IF(k /= sum_crtl_L_nnz)THEN
PRINT*,'ERROR L3_nnz','RANG',rang,'k_L3',k-crtl_L1_nnz-crtl_L2_nnz,'/=','crtl_L3_nnz',crtl_L3_nnz
AA=0._PR;IA=0;JA=0
END IF
END IF
END Subroutine matsys_v2
Subroutine L1_NXL_eqv_1(Ny_l,nnz,k,AA,IA,JA)
INTEGER,INTENT(IN)::Ny_l,nnz
INTEGER,INTENT(INOUT)::k
Real(PR), Dimension(nnz), Intent(Out) :: AA
Integer, Dimension(nnz), Intent(Out) :: IA,JA
Integer::d
!ONLY WHEN A PROCES GOT Nx_l==1
DO d = 1, Ny_l
IF(d == 1)THEN
AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
ELSE IF(d>1 .AND. d<Ny_l)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
ELSE IF(d == Ny_l)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
END IF
END DO
End Subroutine L1_NXL_eqv_1
Subroutine L1(Ny_l,nnz,k,AA,IA,JA)
INTEGER,INTENT(IN)::Ny_l,nnz
INTEGER,INTENT(INOUT)::k
Real(PR), Dimension(nnz), Intent(Out) :: AA
Integer, Dimension(nnz), Intent(Out) :: IA,JA
Integer::d,hit
DO d = 1, Ny_l
IF(d == 1)THEN
AA(k)=alpha; IA(k)=d; JA(k)=d
DO hit = d+1, d+Ny_l, Ny_l-1
IF(hit == d+1)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=hit
ELSE
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=hit
END IF
END DO
ELSE IF(d>1 .AND. d<Ny_l)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
ELSE IF(d == Ny_l)THEN
DO hit = d-1, d
IF(hit == d-1)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=hit
ELSE
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=hit
END IF
END DO
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
END IF
END DO
End Subroutine L1
SUBROUTINE TRACK(k,d)
INTEGER,INTENT(INOUT)::k,d
IF(rang==0)THEN
PRINT*,'RANG',rang,'TRACK k,d',k,d
END IF
END SUBROUTINE TRACK
Subroutine L2(Nx_l,Ny_l,nnz,d1,d2,k,AA,IA,JA)
Integer, Intent(IN) :: Nx_l, Ny_l, nnz
Integer, Intent(INOUT) :: d1, d2, k
Real(PR), Dimension(nnz), Intent(Out) :: AA
Integer, Dimension(nnz), Intent(Out) :: IA,JA
INTEGER :: i, d
DO i = 1, Nx_l-2
DO d = d1,d2
IF(d == d1)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
ELSE IF(d>d1 .AND. d<d2)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
ELSE IF(d == d2)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
END IF
END DO
d1 = d2+1; d2=d2+Ny_l
END DO
End Subroutine L2
Subroutine L3(mul1,mul2,Ny_l,nnz,k,AA,IA,JA)
Integer, Intent(IN) :: mul1, mul2, Ny_l, nnz
Integer, Intent(INOUT) :: k
Real(PR), Dimension(nnz), Intent(Out) :: AA
Integer, Dimension(nnz), Intent(Out) :: IA,JA
INTEGER :: d
DO d = mul1, mul2
IF(d == mul1)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
ELSE IF(d>mul1 .AND. d<mul2)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
ELSE IF(d == mul2)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
END IF
END DO
End Subroutine L3
!--------SUBROUTINE DU SECOND MEMBRE EN FONCTION DE L'ITERATION N ET DU VECTEUR U--------
!--------ET DES CONDITIONS AUX LIMITES
Subroutine vectsource(CT,U,S1,S2,X,Y,T,F)
Implicit None
!---variables----------------------------------
Integer, Intent(In) :: CT, S1, S2
Real(PR), Dimension(it1:itN), Intent(In) :: U
Real(PR), Dimension(LBX:UBX), Intent(IN) :: X
Real(PR), Dimension(0:Ny_g+1), Intent(IN) :: Y !BECAUSE DD 1D => Ny_l == Ny_g
Real(PR), Intent(IN) :: T
Real(PR), Dimension(it1:itN), Intent(INOUT) :: F
Integer :: i,j,k
DO i = S1, S2
DO j = 1, Ny_g
k = j + (i-1)*Ny_g
F(k) = dt * f1(CT,X(i),Y(j),T)
IF(i == 1)THEN
F(k) = F(k) - h1(CT,X(i-1),Y(j),T)*beta
ELSE IF(i == Nx_g)THEN
F(k) = F(k) - h1(CT,X(i+1),Y(j),T)*beta
END IF
IF(j == 1)THEN
F(k) = F(k) - g1(CT,X(i),Y(j-1),T)*gamma
ELSE IF(j == Ny_g)THEN
F(k) = F(k) - g1(CT,X(i),Y(j+1),T)*gamma
END IF
END DO
END DO
F = F +U
End Subroutine vectsource
!DANS LE CAS DE LA DECOMPOSITION DE DOMAINE:
Subroutine vectsource_FULL(CT,U,UG,UD,S1,S2,X,Y,T,F)
Implicit None
!---variables----------------------------------
Integer, Intent(In) :: CT, S1, S2
Real(PR), Dimension(it1:itN), Intent(In) :: U
Real(PR), Dimension(it1-Ny_g:it1-1), Intent(In) :: UG
Real(PR), Dimension(itN+1:itN+Ny_g), Intent(In) :: UD
Real(PR), Dimension(LBX:UBX), Intent(IN) :: X
Real(PR), Dimension(0:Ny_g+1), Intent(IN) :: Y !BECAUSE DD 1D => Ny_l == Ny_g
Real(PR), Intent(IN) :: T
Real(PR), Dimension(it1:itN), Intent(INOUT) :: F
Integer :: i,j,k
DO i = S1, S2
DO j = 1, Ny_g
k = j + (i-1)*Ny_g
F(k) = dt * f1(CT,X(i),Y(j),T)
IF(i == 1)THEN
F(k) = F(k) - h1(CT,X(i-1),Y(j),T)*beta
ELSE IF(i == S1 )THEN !.AND. rang /= 0)THEN not needed with the current order if... else if
F(k) = F(k) - beta * UG(k-Ny_g) !CL dirichlet frontiere immergee
ELSE IF(i == Nx_g)THEN
!PRINT*,'RANG',rang,'it1,itN',it1,itN,'LBX,UBX',lbound(X,1),UBOUND(X,1),'k',k,'i,j',i,j
F(k) = F(k) - h1(CT,X(i+1),Y(j),T)*beta
ELSE IF(i == S2)THEN !.AND. rang /= Np-1)THEN not needed with the current order else if... else if
F(k) = F(k) - beta * UD(k+Ny_g) !CL dirichlet frontiere immergee
END IF
IF(j == 1)THEN
F(k) = F(k) - g1(CT,X(i),Y(j-1),T)*gamma
ELSE IF(j == Ny_g)THEN
F(k) = F(k) - g1(CT,X(i),Y(j+1),T)*gamma
END IF
END DO
END DO
F = F +U
End Subroutine vectsource_FULL
End Module mod_matsys
!!$DO d = 1, Ny_l
!!$ IF(d == 1)THEN
!!$ AA(k)=alpha; IA(k)=d; JA(k)=d
!!$ DO hit = d+1, d+Ny_l, Ny_l-1
!!$ IF(hit == d+1)THEN
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=hit
!!$ ELSE
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=hit
!!$ END IF
!!$ END DO
!!$ ELSE IF(d>1 .AND. d<Ny_l)THEN
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
!!$ k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
!!$ ELSE IF(d == Ny_l)THEN
!!$ DO hit = d-1, d
!!$ IF(hit == d-1)THEN
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=hit
!!$ ELSE
!!$ k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=hit
!!$ END IF
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
!!$ END DO
!!$ END IF
!!$ END DO
!!$IF(Nx_l>2)THEN
!!$ d1 = Ny_l+1; d2 = 2*Ny_l
!!$ DO i = 1, Nx_l-2
!!$ DO d = d1,d2
!!$ IF(d == d1)THEN
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
!!$ k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
!!$ ELSE IF(d>d1 .AND. d<d2)THEN
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
!!$ k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
!!$ ELSE IF(d == d2)THEN
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
!!$ k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
!!$ END IF
!!$ END DO
!!$ d1 = d2+1; d2=d2+Ny_l
!!$ END DO
!!$ END IF
!!$Subroutine matsys(nnz,AA,IA,JA)
!!$ Integer, Intent(In) :: nnz
!!$ Real(PR), Dimension(:), Allocatable, Intent(Out) :: AA
!!$ Integer, Dimension(:), Allocatable, Intent(Out) :: IA,JA
!!$ Integer :: i,j,k
!!$ k=1
!!$ Allocate(AA(nnz),IA(nnz),JA(nnz))
!!$ Do i=1,na
!!$ Do j=1,na
!!$ If (i==j) Then !diagonale principale
!!$ AA(k)=alpha
!!$ IA(k)=i
!!$ JA(k)=j
!!$ k=k+1
!!$ ElseIf ((i==j-1) .and. (modulo(i,nx)/=0)) Then !diagonale sup
!!$ AA(k)=beta
!!$ IA(k)=i
!!$ JA(k)=j
!!$ k=k+1
!!$ ElseIf ((i==j+1) .and. (i/=1) .and. (modulo(j,ny)/=0)) Then !diagonale inf
!!$ AA(k)=beta
!!$ IA(k)=i
!!$ JA(k)=j
!!$ k=k+1
!!$ ElseIf (j==ny+i) Then !diagonale la plus a droite
!!$ AA(k)=gamma
!!$ IA(k)=i
!!$ JA(k)=j
!!$ k=k+1
!!$ ElseIf (i==j+nx) Then !diagonale la plus a gauche
!!$ AA(k)=gamma
!!$ IA(k)=i
!!$ JA(k)=j
!!$ k=k+1
!!$ End If
!!$ End Do
!!$ End Do
!!$End Subroutine matsys
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/Code_Dirichlet_LAST/mod_parametres.f90 | !-----------------------------------------------
! CE MODULE CONTIENT LES PARAMETRES DU PROBLEME
!-----------------------------------------------
Module mod_parametres
USE mpi
Implicit None
!---Précision des calculs -------------------
Integer, Parameter :: PR=8 !simple précision
!--------------------------------------------
!---Parametres géométriques-----------------
Real(PR), Parameter :: Lx=1._PR !Longueur de la barre
Real(PR), Parameter :: Ly=1._PR !Largeur de la barre
Real(PR), Parameter :: D=1._PR !Coefficient de diffusion
!--------------------------------------------
!PARAMETRE DE VISUALISATION:
INTEGER :: sysmove
!---Parametres numériques-------------------
!g means global Domain GLobal matrix WITHOUT DD ADDITIVE
!l means local Domain local matrix
Integer :: nnz_g
Integer, Parameter :: Nx_g=200 !lig nes de A (discrétisation en x)
Integer, Parameter :: Ny_g=100 !colonnes de A (discrétisation en y)
Integer, Parameter :: Na_g=Nx_g*Ny_g !taille de la matrice A
Integer, Parameter :: Nt=30 !discrétisation du temps
Real(PR), Parameter :: dx=1._PR/(Real(Nx_g)+1) ! pas en x
Real(PR), Parameter :: dy=1._PR/(Real(Ny_g)+1) ! pas en y
Real(PR), Parameter :: Tf=2.0_PR !temps final de la simulation
Real(PR), Parameter :: dt=Tf/(Real(Nt)) !pas de temps
Real(PR), Parameter :: pi=4._PR*atan(1._PR)
!----------------------------------------------------------------------------------------------------------------
Real(PR), Parameter :: alpha =1._PR+(2._PR*D*dt/(dx**2._PR))+(2._PR*D*dt/(dy**2._PR)) !
Real(PR), Parameter :: beta = (-D*dt)/(dx**2._PR) !AL ! CF coefficients matrice
Real(PR), Parameter :: gamma =(-D*dt)/(dy**2._PR) !AP
!----------------------------------------------------------------------------------------------------------------
!-------------------------------------------
!---PARAMETRES MPI--------------------------
INTEGER ::rang,Pivot
INTEGER ::Np
INTEGER ::stateinfo
INTEGER,DIMENSION(MPI_STATUS_SIZE)::status
CHARACTER(LEN=3) ::rank
INTEGER ::TAG !FOR TAG FILE
!------------------------------------------
!---DEFINE INTERVALLE SUIVANT Y PAR PROCS------
INTEGER ::S1_old, S2_old, it1_old, itN_old !avant call charge_overlap
INTEGER ::S1
INTEGER ::S2 !=> X_i^(rang) \in [|S1;S2|]
INTEGER ::it1
INTEGER ::itN !=> P(OMEGA^(rang)) \in [|it1;itN|]
!INTEGER ::overlapd
!INTEGER ::overlapg
INTEGER,PARAMETER::overlap=1
INTEGER ::Na_l !NBR rows or cols in local matrix
!na_loc == (S2-S1+1)*Ny
INTEGER ::Nx_l !Nx local will be set to S2-S1+1
INTEGER ::Ny_l
INTEGER ::nnz_l !nbr de non zero in local matrix
INTEGER ::crtl_nnz_l !control de nnz
!since a A_l matrix local is made by block D AND C such:
!avec s=alpha, x=gamma et v=beta:
![D][C][0][0] ! |s x 0 0| ! |v 0 0 0| ! A_l.rows=Nx_l*Ny_l=A_l.cols
![C][D][C][0] ![D]=|x s x 0| ![C]=|0 v 0 0| ! D.rows=D.cols=Ny_l
![0][C][D][C] ! |0 x s x| ! |0 0 v 0| ! C.cols=C.rows=Ny_l
![0][0][C][D] ! |0 0 x s| ! |0 0 0 v| !We got (Nx_l) [D] block & (Nx_l-1) [C] upper block
!& (Nx_l-1) [C] lower block
!SUCH THAT crtl_nnz_l=(Nx_l*Ny_l) + 2 * (Nx_l) * (Ny_l - 1) + 2 * (Nx_l - 1) * (Ny_l)
INTEGER ::D_rows !will be set to Ny_l
INTEGER ::D_nnz !will be set to D_rows+2*(D_rows-1)
INTEGER ::C_rows !will be set to Ny_l
INTEGER ::C_nnz !will be set to C_rows
! WE DEFINE a control nnz_l parameter over L1, L2, L3 such that:
!|[D][C][0][0]| = [L1]
INTEGER ::crtl_L1_nnz !will be set to D_nnz+C_nnz
!|[C][D][C][0]| = [L2]
!|[0][C][D][C]|
INTEGER ::crtl_L2_nnz !will be set to (Nx_l-2)*(D_nnz+2*C_nnz)
!|[0][0][C][D]| = [L3]
INTEGER ::crtl_L3_nnz !will be set to D_nnz+C_nnz
!SUCH THAT THE RELATION (*) NEED TO BE .TRUE.:
!(*)crtl_L1_nnz+crtl_L2_nnz+crtl_L3_nnz = crtl_nnz_l = nnz_l
INTEGER ::sum_crtl_L_nnz !sum of crtl_Li_nnz
!DANS LE CAS OU Nx_l == 1:
INTEGER :: crtl_L1_nnz_Nxl_EQV_1 ! will be set to D_nnz
!---variables---------------------------------!
Real(PR), Dimension(:), Allocatable :: X
Real(PR), Dimension(:), Allocatable :: Y !Ny_g+2
Real(PR), Dimension(:), Allocatable :: T !Nt+2
Real(PR), Dimension(:), Allocatable :: AA
Integer, Dimension(:), Allocatable :: IA,JA
Real(PR), Dimension(:), Allocatable :: U,Uo,F !Na_l
Real(Pr), Dimension(:), Allocatable :: UG, UD ! CL FROM BORDER IMMERGEE need to be set at zero
Real(PR) :: res,t1,t2 !résidu du grandconj
Integer :: k,i,j,it,CT
INTEGER ::LBX !init in mod_fonctions, para_param
INTEGER ::UBX
!VARIABLES POUR LA BOUCLE SCHWARZ, CONVERGENCE DD:
REAL(PR) :: Norm1, Norm2, C1, err
REAL(PR), PARAMETER :: err_LIM = 0.0000000001_PR
INTEGER :: step
End Module mod_parametres
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/Code_Dirichlet_LAST/mod_sol.f90 | module mod_sol
use mpi
use mod_parametres
IMPLICIT NONE
!*** MODULE ModSOL POUR DONNER LA SOLUTION EXACTE ET
!*** POUR GERER L'ENREGISTREMENT DE LA SOLUTION DANS DES FICHIERS
!*** SUBROUTINE POUR APPELLER UN SCRIPT GNUPLOT POUR LA VISUALISATION
CONTAINS
SUBROUTINE UEXACT(U,userchoice)!userchoice==CT
INTEGER,INTENT(INOUT)::userchoice
REAL(PR),DIMENSION(it1:itN),INTENT(IN)::U
REAL(PR),DIMENSION(:),ALLOCATABLE::UEXA,DIFF
REAL(PR)::ErrN2_RED,ErrN2,Ninf_RED,Ninf
CHARACTER(len=3)::CAS!rank,CAS
!INITIALISATION DE UEXA SUIVANT LE CAS SOURCE
ALLOCATE(UEXA(it1:itN))
WRITE(CAS,fmt='(1I3)')userchoice
OPEN(TAG,file='EXACTE_ERREUR/SOL_EXACTE_CAS'//trim(adjustl(CAS))//'_ME'//trim(adjustl(rank))//'.dat')
SELECT CASE(userchoice)
CASE(1)!F1
DO i=S1,S2
DO j=1,Ny_g
k=j+(i-1)*Ny_g
UEXA(k)=X(i)*(1-X(i))*Y(j)*(1-Y(j))
WRITE(TAG,*)X(i),Y(j),UEXA(k)
END DO
END DO
CASE(2)!F2
DO i=S1,S2
DO j=1,Ny_g
k=j+(i-1)*Ny_g
UEXA(k)=sin(X(i))+cos(Y(j))
WRITE(TAG,*)X(i),Y(j),UEXA(k)
END DO
END DO
CASE DEFAULT!F3 PAS DE SOL EXACTE
PRINT*,'PAS DE SOLUTION EXACTE POUR CE CAS (F3)'
END SELECT
CLOSE(TAG)
!SUR LE DOMAINE [|S1;S2|]x[|1;Ny_g|]:
!ERREUR NORME_2:
ALLOCATE(DIFF(it1:itN))
DIFF=UEXA-U(it1:itN)
ErrN2_RED=DOT_PRODUCT(DIFF,DIFF)
CALL MPI_ALLREDUCE(ErrN2_RED,ErrN2,1,MPI_DOUBLE_PRECISION,MPI_SUM,MPI_COMM_WORLD,stateinfo)
ErrN2=SQRT(ErrN2)
!ERREUR NORME INFINIE
Ninf_RED=MAXVAL(ABS(UEXA(it1:itN)-U(it1:itN)))
CALL MPI_ALLREDUCE(Ninf_RED,Ninf,1,MPI_DOUBLE_PRECISION,MPI_MAX,MPI_COMM_WORLD,stateinfo)
PRINT*,'PAR DOMAINE: ','ERREUR NORME 2 :=',ErrN2,' ERREUR NORME INFINIE :=',Ninf
OPEN(TAG,file='EXACTE_ERREUR/ErrABSOLUE_PAR_DOMAINE'//trim(adjustl(CAS))//'_ME'//trim(adjustl(rank))//'.dat')
DO i=S1,S2
DO j=1,Ny_g!GAP(i,1),GAP(i,2)
k=j+(i-1)*Ny_g!Ny_g
WRITE(TAG,*)X(i),Y(j),-DIFF(k)
END DO
END DO
CLOSE(TAG)
!SUR LE DOMAINE [|S1_old;S2_old|]x[|1;Ny_g|]:
ErrN2_RED=0.0_PR; ErrN2=0.0_PR; Ninf_RED=0.0_PR; Ninf=0.0_PR
!DIFF(it1_old:itN_old)=UEXA(it1_old:itN_old)-U(it1_old:itN_old)
ErrN2_RED=DOT_PRODUCT(DIFF(it1_old:itN_old),DIFF(it1_old:itN_old))
CALL MPI_ALLREDUCE(ErrN2_RED,ErrN2,1,MPI_DOUBLE_PRECISION,MPI_SUM,MPI_COMM_WORLD,stateinfo)
ErrN2=SQRT(ErrN2)
Ninf_RED=MAXVAL(ABS(UEXA(it1_old:itN_old)-U(it1_old:itN_old)))
CALL MPI_ALLREDUCE(Ninf_RED,Ninf,1,MPI_DOUBLE_PRECISION,MPI_MAX,MPI_COMM_WORLD,stateinfo)
PRINT*,'SUR [|S1old;S2old|]: ','ERREUR NORME 2 :=',ErrN2,' ERREUR NORME INFINIE :=',Ninf
OPEN(TAG,file='EXACTE_ERREUR/ErrABSOLUE_oldDD'//trim(adjustl(CAS))//'_ME'//trim(adjustl(rank))//'.dat')
DO i=S1_old,S2_old
DO j=1,Ny_g!GAP(i,1),GAP(i,2)
k=j+(i-1)*Ny_g!Ny_g
WRITE(TAG,*)X(i),Y(j),-DIFF(k)
END DO
END DO
CLOSE(TAG)
DEALLOCATE(DIFF,UEXA)
END SUBROUTINE UEXACT
SUBROUTINE WR_U(U,IT_TEMPS)
INTEGER,INTENT(IN)::IT_TEMPS
REAL(PR),DIMENSION(it1_old:itN_old),INTENT(INOUT)::U
CHARACTER(len=3)::CAS
CHARACTER(len=3)::Ntps
INTEGER::i,j
WRITE(CAS,fmt='(1I3)')CT;WRITE(Ntps,fmt='(1I3)')IT_TEMPS
OPEN(10+rang,file='SOL_NUMERIQUE/U_ME'//trim(adjustl(rank))&
//'_T'//trim(adjustl(Ntps)))
SELECT CASE(CT)
CASE(1)
DO i=S1_old,S2_old
DO j=1,Ny_g
k=j+(i-1)*Ny_g
IF(i-1==0)THEN
WRITE(10+rang,*)0.0_PR,Y(j),0.0_PR
END IF
IF(i+1==Nx_g+1)THEN
WRITE(10+rang,*)Lx,Y(j),0.0_PR
END IF
IF(j-1==0)THEN
WRITE(10+rang,*)X(i),0.0_PR,0.0_PR
END IF
IF(j+1==Ny_g+1)THEN
WRITE(10+rang,*)X(i),Ly,0.0_PR
END IF
WRITE(10+rang,*)X(i),Y(j),U(k)
END DO
END DO
CASE(2)
DO i=S1_old,S2_old
DO j=1,Ny_g
k=j+(i-1)*Ny_g
IF(i==1)THEN!BC OUEST (H)
WRITE(10+rang,*)0.0_PR,Y(j),cos(Y(j))
END IF
IF(i==Nx_g)THEN!BC EST (H)
WRITE(10+rang,*)Lx,Y(j),cos(Y(j))+sin(Lx)
END IF
IF(j==1)THEN!BC SUD (G)
WRITE(10+rang,*)X(i),0.0_PR,1.0_PR+sin(X(i))
END IF
IF(j==Ny_g)THEN!BC NORD (G)
WRITE(10+rang,*)X(i),Ly,cos(Ly)+sin(X(i))
END IF
WRITE(10+rang,*)X(i),Y(j),U(k)
END DO
END DO
CASE(3)
DO i=S1_old,S2_old
DO j=1,Ny_g
k=j+(i-1)*Ny_g
IF(i-1==0)THEN!BC OUEST OU EST (H)
WRITE(10+rang,*)0.0_PR,Y(j),1.0_PR
END IF
IF(i+1==Nx_g+1)THEN!BC OUEST OU EST (H)
WRITE(10+rang,*)Lx,Y(j),1.0_PR
END IF
IF(j-1==0)THEN!BC SUD OU NORD (G)
WRITE(10+rang,*)X(i),0.0_PR,0.0_PR
END IF
IF(j+1==Ny_g+1)THEN!BC SUD OU NORD (G)
WRITE(10+rang,*)X(i),Ly,0.0_PR
END IF
WRITE(10+rang,*)X(i),Y(j),U(k)
END DO
END DO
END SELECT
CLOSE(10+rang)
END SUBROUTINE WR_U
SUBROUTINE VIZU_SOL_NUM(userchoice)!sequentiel call by proc 0 at the end
INTEGER,INTENT(INOUT)::userchoice
CHARACTER(LEN=12)::VIZU
INTEGER::vi1,vi2
VIZU='VIZU_PLT.plt'
PRINT*,'*****************************************************************************************'
PRINT*,'************** VISUALISATION SOLUTION POUR LE CAS #',userchoice,' ***********************'
PRINT*,'*****************************************************************************************'
PRINT*,'************* SACHANT QUE DT=',dt,'ET ITMAX=',Nt,':'
PRINT*,'*****************************************************************************************'
PRINT*,'** ENTREZ LE NUMERO DE L''ITERATION A LAQUELLE VOUS VOULEZ COMMENCER LA VISUALISATION **'
READ*,vi1
PRINT*,'*****************************************************************************************'
PRINT*,'*****************************************************************************************'
PRINT*,'*** ENTREZ LE NUMERO DE L''ITERATION A LAQUELLE VOUS VOULEZ STOPPER LA VISUALISATION ***'
READ*,vi2
PRINT*,'*****************************************************************************************'
PRINT*,'*****************************************************************************************'
OPEN(50,file=VIZU)
SELECT CASE(userchoice)
CASE(1)
WRITE(50,*)'set cbrange[0:1]'
CASE(2)
WRITE(50,*)'set cbrange[0.8:2]'
CASE(3)
WRITE(50,*)'set cbrange[0:1]'
END SELECT
WRITE(50,*)'set dgrid3d,',Nx_g+2,',',Ny_g+2; WRITE(50,*)'set hidden3d'; WRITE(50,*)'set pm3d'
WRITE(50,*)'do for [i=',vi1,':',vi2,']{splot ''SOL_NUMERIQUE/U.dat'' index i u 1:2:3 with pm3d at sb}'
CLOSE(50)
call system('gnuplot -p VIZU_PLT.plt')
END SUBROUTINE VIZU_SOL_NUM
SUBROUTINE VIZU_SOL_NUM_ONLY_Nt(userchoice,MINU,MAXU)!sequentiel call by proc 0 at the end
INTEGER,INTENT(INOUT) :: userchoice
REAL(PR),INTENT(IN) :: MINU, MAXU
CHARACTER(LEN=12)::VIZU
VIZU='VIZU_PLT.plt'
PRINT*,'*****************************************************************************************'
PRINT*,'************** VISUALISATION SOLUTION POUR LE CAS #',userchoice,' ***********************'
PRINT*,'*****************************************************************************************'
PRINT*,'************* SACHANT QUE DT=',dt,'ET ITMAX=',Nt,':'
PRINT*,'*****************************************************************************************'
PRINT*,'** VISUALISATION AU TEMPS FINAL **'
PRINT*, (Nt)*dt,' secondes'
PRINT*,'*****************************************************************************************'
OPEN(50,file=VIZU)
SELECT CASE(userchoice)
CASE(1)
WRITE(50,*)'set cbrange[',MINU,':',MAXU,']'
CASE(2)
WRITE(50,*)'set cbrange[',MINU,':',MAXU,']'
CASE(3)
WRITE(50,*)'set cbrange[',MINU,':',MAXU,']'
END SELECT
WRITE(50,*)'set dgrid3d,',Nx_g+2,',',Ny_g+2; WRITE(50,*)'set hidden3d'; WRITE(50,*)'set pm3d'
WRITE(50,*)'splot ''SOL_NUMERIQUE/U.dat'' u 1:2:3 with pm3d at sb'
CLOSE(50)
call system('gnuplot -p VIZU_PLT.plt')
END SUBROUTINE VIZU_SOL_NUM_ONLY_Nt
end module mod_sol
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/DD_Neuman_TRUE_LAST/main.f90 | !-----------------------------------
! MAIN : PROGRAMME PRINCIPAL
!-----------------------------------
Program main
!-------------modules-----------------!
USE mpi
use mod_parametres
use mod_charge
use mod_comm
use mod_sol
use mod_fonctions
use mod_gradconj
use mod_gmres
use mod_matsys
!--------------------------------------!
Implicit None
INTEGER :: DIMKRYLOV
INTEGER :: ILOOP
!VARIABLES POUR SAVE LE TEMPS DE CALCUL:
REAL(PR) :: TPS1, TPS2, MAX_TPS
REAL(PR) :: MINU, MAXU
REAL(PR) :: RED_MINU, RED_MAXU
REAL(PR) :: RED_SUMC, MAXC, TPSC1, TPSC2
REAL(PR) :: STA, STB, STM
!------------INIT REGION PARA-----------------!
!********* DEBUT REGION PARA:
CALL MPI_INIT(stateinfo) !INITIALISATION DU //LISME
CALL MPI_COMM_RANK(MPI_COMM_WORLD,rang,stateinfo) !ON RECUPERE LES RANGS
!AU SEIN DE L'ENSEMBLE MPI_COMM_WORLD
CALL MPI_COMM_SIZE(MPI_COMM_WORLD,Np,stateinfo) !ET LE NOMBRE DU PROCESSUS
!---------------------------------------------!
!******** READ USERCHOICE FOR CT AND SHARE IT WITH OTHER PROCESS
IF(rang==0)THEN
CALL SYSTEM('make cleanREP')
Print*,"______RESOLUTION DE L'ÉQUATION : DD SCHWARZ ADDITIVES //______"
!---initialisation des variables cas test-------------
Print*,"Donnez le cas test (1,2 ou 3):"
Read*,CT
PRINT*," POUR VISUALISATION ENTREZ 1, SINON 0"
read*,sysmove
END IF
CALL MPI_BCAST(CT,1,MPI_INTEGER,0,MPI_COMM_WORLD,stateinfo)
CALL MPI_BCAST(sysmove,1,MPI_INTEGER,0,MPI_COMM_WORLD,stateinfo)
TPS1=MPI_WTIME()
!******** COMPUTE SOME MATRIX_G DATA & GEO TIME DATA
nnz_g=5*Na_g-2*Nx_g-2*Ny_g !nb d'elt non nul dans la matrice A_g
IF(rang==0)THEN
print*,"Nombre éléments non nuls du domaine A_g non DD ADDITIVE : nnz_g=",nnz_g
print*,'Nombre de ligne Nx_g, colonne Ny_g de A_g',Nx_g,Ny_g
Print*,"Lx=",Lx
Print*,"Ly=",Ly
Print*,"D=",D
Print*," "
Print*,"dx=",dx
Print*,"dy=",dy
Print*,"dt",dt
Print*,"Tfinal=",Tf,"secondes"
Print*," "
print*,"alpha=",alpha
print*,"beta=",beta
print*,"gamma=",gamma
Print*," "
END IF
!******* SET UP ONE TAG FILE NAMED TAG TO i/o:
TAG=10+rang
WRITE(rank,fmt='(1I3)')rang !WATCH OUT IF rang>999
!******* COMPUTE SIZE OF LOCAL DD OVER LOCAL MATRIX A_l SIZE:
OPEN(TAG,file='CHARGE/CHARGE'//trim(adjustl(rank))//'.dat')
CALL MODE1(rang, Np, S1, S2, it1, itN)!-->DISTRIBUTION DE LA CHARGE PAR PROCESSUS
S1_old = S1; S2_old = S2; it1_old = it1; itN_old = itN
WRITE(TAG,*)'AVANT OVERLAP', S1, S2, it1, itN
CALL CHARGE_OVERLAP(Np, rang, S1, S2, it1, itN)!-->MODIFICATION DE LA CHARGE POUR DIRICHLET
WRITE(TAG,*)'APRES OVERLAP DIRICHLET', S1, S2, it1, itN
CALL CHARGE_NEUMAN(it1, itN, rang, Np, S1, S2)!-->MODIFICATION DE LA CHARGE CALCULEE PAR (CHARGE_OVERLAP) POUR NEUMANN
WRITE(TAG,*)'OVERLAP FINAL NEUMAN', S1, S2, it1, itN
Nx_l = S2 - S1 + 1; Ny_l = Ny_g; Na_l = Nx_l * Ny_l
nnz_l = 5 * Na_l - 2 * Nx_l - 2 * Ny_l
crtl_nnz_l = (Nx_l*Ny_l) + 2 * (Nx_l) * (Ny_l - 1) + 2 * (Nx_l - 1) * (Ny_l)
WRITE(TAG,*)'Nxl,Ny_l,Na_l', Nx_l, Ny_l, Na_l
WRITE(TAG,*)'nnz_l,crtl_nnz_l', nnz_l,crtl_nnz_l
CLOSE(TAG)
!CALCUL DES DIMMENSIONS DES MATRICES:
D_rows = Ny_l; D_nnz = D_rows+2*(D_rows-1)
C_rows = Ny_l; C_nnz = C_rows
crtl_L1_nnz = D_nnz+C_nnz
crtl_L2_nnz = (Nx_l-2)*(D_nnz+2*C_nnz)
crtl_L3_nnz = D_nnz+C_nnz
sum_crtl_L_nnz = crtl_L1_nnz+crtl_L2_nnz+crtl_L3_nnz
crtl_L1_nnz_Nxl_EQV_1 = D_nnz
!test pour la verification du nombre de non zero des matrices locales:
IF(Nx_l > 1)THEN
IF(crtl_nnz_l/=nnz_l .AND. nnz_l/=sum_crtl_L_nnz)THEN
PRINT*,'ERROR,RANG=',rang,'Local Matrix A_l.rows,A_l.cols',Nx_l,Ny_l,nnz_l,&
&'A_l_nnz,crtl_nnz_l,sum_crtl_L_nnz',nnz_l,crtl_nnz_l,sum_crtl_L_nnz
GOTO 9999
END IF
ELSE IF(Nx_l == 1)THEN
IF(crtl_nnz_l/=nnz_l .AND. nnz_l/=crtl_L1_nnz_Nxl_EQV_1)THEN
PRINT*,'ERROR,RANG=',rang,'Local Matrix A_l.rows,A_l.cols',Nx_l,Ny_l,nnz_l,&
&'A_l_nnz,crtl_nnz_l,crtl_L1_nnz_Nxl_EQV_1',nnz_l,crtl_nnz_l,crtl_L1_nnz_Nxl_EQV_1
GOTO 9999
END IF
END IF
!******* COMPUTE CARTESIAN GRID OVER PROCESS i.e CHARGE APPLY TO X,Y,T
IF(Np/=1)THEN
CALL param_para(rang,Np,S1,S2,Ny_l,X,Y,T)
ELSE
CALL param(X,Y,T)
PRINT*,'EN SEQUENTIEL'
END IF
!****** ALLOCATE Uo ET U
ALLOCATE(U(it1:itN),Uo(it1:itN))
Uo = 1._PR !CI pour le gradient conjugué
U = 1._PR !vecteur solution initialisé
!SAVE SOL :
call WR_U(U,0)
CALL matsys_v2(nnz_l,Nx_l,Ny_l,AA,IA,JA)!-->on construit A au format COO (AA,IA,JA)
OPEN(TAG,file='MAT_VIZU/matrice_A_'//trim(adjustl(rank))//'.dat')!-->POUR VISUALISER LES MATRICES
DO i=1,nnz_l
WRITE(TAG,*)AA(i),IA(i),JA(i)
END DO
CLOSE(TAG)
ALLOCATE(F(it1:itN))!-->SECOND MEMBRE
ALLOCATE(UG(LBUG:UBUG),UD(LBUD:UBUD))
UG = 0.0_PR; UD = 0.0_PR !-->INITITALISATION
!---boucle principale (résolution systeme) et ecriture a chaque itération---
Print*,"----------DÉBUT DU CALCUL DE LA SOLUTION------------"
Pivot=(Np-mod(Np,2))/2 !-->!PIVOT DE COMMUNICATION:
RED_SUMC = 0.0_PR
DIMKRYLOV = 5!Na_l-5
IF(Np>1)THEN
boucle_temps:Do ILOOP=1,Nt !-->BOUCLE EN TEMPS
err = 1.0_PR; step = 1; Norm2 = 0.0_PR
!STA = MPI_WTIME()
boucle_CV_SWHARZ:Do while(err>err_LIM .OR. step<3)!-->BOUCLE POUR CONVERGENCE DE SCHWARZ
step = step +1
Norm1 = Norm2
!Norm2 = 0.0_PR
call vectsource_FULL(CT,U,UG,UD,S1,S2,X,Y,T(ILOOP),F)!-->SECOND MEMBRE F=Uo+dt*SOURCE_TERME+CL
!call MOD_gradconj_SPARSE(AA,IA,JA,f,Uo,U,res,k,it1,itN)
!call MOD_jacobi_SPARSE(AA,IA,JA,F,Uo,U,res,k)
call BICGSTAB(it1, itN, AA, IA, JA, U, F, 0.0000000001_PR)! solver le plus adapté au PB
!call GMres_COO(AA,IA,JA,F,Uo,U,res,k,Na_l,it1,itN,DIMKRYLOV)! mal interfacé
TPSC1 = MPI_WTIME()
!CALL COMM_PTOP_2WAY(U,UG,UD)!-->UNE PETITE REDUCTION DU TEMPS DE COMMUNICATION(NP>=5)
call COMM_PTOP(U,UG,UD)!-->COMMUNICATION DES FRONTIERES "IMMERGEE"
TPSC2 = MPI_WTIME()
RED_SUMC = RED_SUMC + (TPSC2-TPSC1)
Uo=U !-->SWAP
!POUR LE CALCUL DE L'ERREUR DE SCHWARZ(C1,Nomr1,Norm2,err):
if(rang==0)then
C1 = DOT_PRODUCT(U(itN-Ny_l+1:itN),U(itN-Ny_l+1:itN))
else if(rang==Np-1)then
C1 = DOT_PRODUCT(U(it1:it1+Ny_l-1),U(it1:it1+Ny_l-1))
else
C1 = DOT_PRODUCT(U(it1:it1+Ny_l-1),U(it1:it1+Ny_l-1)) +DOT_PRODUCT(U(itN-Ny_l+1:itN),U(itN-Ny_l+1:itN))
end if
!C1 = DOT_PRODUCT(U(it1:itN),U(it1:itN))!-->AUTRE METHODE POUR LE CALCUL DE C1
Call MPI_ALLreduce(C1,Norm2,1,MPI_DOUBLE_PRECISION,MPI_SUM,MPI_COMM_WORLD,stateinfo)
Norm2 = SQRT(Norm2)
err = abs(Norm1-Norm2)
!PRINT*,'err=',err,'step',step,'Norm2',Norm2,'Norm1',Norm1
END DO boucle_CV_SWHARZ
!STB = MPI_WTIME()
if(mod(ILOOP,10)==0)then
Print*,'IT TEMPS',ILOOP
end if
End DO boucle_temps
!CALL MPI_ALLREDUCE(STB-STA,STM,1,MPI_DOUBLE,MPI_MAX,MPI_COMM_WORLD,stateinfo)
!PRINT*,'STM',STM,'STEP',STEP
ELSE IF(Np==1)THEN
bboucle_temps:Do ILOOP=1,Nt
call vectsource_FULL(CT,U,UG,UD,S1,S2,X,Y,T(ILOOP),F)
!call MOD_gradconj_SPARSE(AA,IA,JA,f,Uo,U,res,k,it1,itN)
!call MOD_jacobi_SPARSE(AA,IA,JA,F,Uo,U,res,k)
call BICGSTAB(it1, itN, AA, IA, JA, U, F, 0.000000000001_PR)
!call GMres_COO(AA,IA,JA,F,Uo,U,res,k,Na_l,it1,itN,DIMKRYLOV)
Uo=U !SWAP
if(mod(ILOOP,10)==0)then
Print*,'IT TEMPS',ILOOP
end if
End DO bboucle_temps
END IF
!----------------------------------------------
!SAVE SOL :
call WR_U(U,Nt)
DEALLOCATE(UG,UD)
!WRITE SOL EXACTE:
IF(CT<3)THEN
call UEXACT(U,CT)
END IF
RED_MINU = minval(U)
RED_MAXU = maxval(U)
CALL MPI_ALLREDUCE(RED_MINU,MINU,1,MPI_DOUBLE_PRECISION,MPI_MIN,MPI_COMM_WORLD,stateinfo)
CALL MPI_ALLREDUCE(RED_MAXU,MAXU,1,MPI_DOUBLE_PRECISION,MPI_MAX,MPI_COMM_WORLD,stateinfo)
if(Np>1)then
CALL MPI_ALLREDUCE(RED_SUMC,MAXC,1,MPI_DOUBLE_PRECISION,MPI_MAX,MPI_COMM_WORLD,stateinfo)
end if
DEALLOCATE(U,Uo,X,Y,T,AA,IA,JA,F)
TPS2=MPI_WTIME()
CALL MPI_ALLREDUCE(TPS2-TPS1,MAX_TPS,1,MPI_DOUBLE_PRECISION,MPI_MAX,MPI_COMM_WORLD,stateinfo)
IF(rang==0)THEN
PRINT*,'TEMPS CALCUL=',MAX_TPS,' TEMPS COMM=',MAXC
END IF
CALL MPI_BARRIER(MPI_COMM_WORLD,stateinfo)
IF(crtl_nnz_l == nnz_l)THEN
GOTO 6666
END IF
9999 PRINT*,rang,'GOTO9999crtl_nnz_l /= nnz_l ERROR',crtl_nnz_l,nnz_l
6666 PRINT*,rang,'GOTO6666NEXT INSTRUCTION IS MPI_FINALIZE',crtl_nnz_l,nnz_l
!---ecriture solution finale--------------------------
!call CONCAT_VIZU(sysmove)
call CONCAT_VIZU_ONLY_Nt(sysmove,MINU,MAXU)
CALL MPI_FINALIZE(stateinfo)
CONTAINS
Subroutine CONCAT_VIZU(sysmove)
Integer, Intent(INOUT):: sysmove
CHARACTER(LEN=3):: NNT
CHARACTER(LEN=1)::ESPACE
CHARACTER(LEN=20)::NFILE,OUT_FILE
INTEGER::i
!VIZUALISATION SEQUENTIELLE: ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE RANG DIFFERENTS DANS UN FICHIER
IF(rang==0.AND.sysmove==1)THEN
ESPACE=' '
DO i=Nt,Nt!0,Nt
WRITE(NNT,fmt='(1I3)')i;
NFILE='U_ME*'//'_T'//trim(adjustl(NNT));OUT_FILE='UT_'//trim(adjustl(NNT))//'.dat'
!ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE RANG DIFFERENTS DANS UN FICHIER
CALL system('cat SOL_NUMERIQUE/'//NFILE//' >> SOL_NUMERIQUE/'//OUT_FILE)
CALL system('rm SOL_NUMERIQUE/'//NFILE)
OPEN(20,file='SOL_NUMERIQUE/'//OUT_FILE,position='append')
SELECT CASE(CT)!ICI IL FAUT RAJOUTER LES POINTS AUX COINS DU DOMAINES
CASE(1)
WRITE(20,*)0.0d0,0.0d0,0.0d0;WRITE(20,*)Lx,0.0d0,0.0d0
WRITE(20,*)0.0d0,Ly,0.0d0;WRITE(20,*)Lx,Ly,0.0d0
CASE(2)
WRITE(20,*)0.0d0,0.0d0,1.0d0;WRITE(20,*)Lx,0.0d0,1.0d0+sin(Lx)
WRITE(20,*)0.0d0,Ly,cos(Ly);WRITE(20,*)Lx,Ly,cos(Ly)+sin(Lx)
CASE(3)
WRITE(20,*)0.0d0,0.0d0,0.5d0;WRITE(20,*)Lx,0.0d0,0.5d0!TEMPERATURES IMPOSEES DIFFERENTES, ON MOYENNE:((G+H)/2)
WRITE(20,*)0.0d0,Ly,0.5d0;WRITE(20,*)Lx,Ly,0.5d0
END SELECT
WRITE(20,fmt='(1A1)')ESPACE
WRITE(20,fmt='(1A1)')ESPACE
CLOSE(20)
!ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE TEMPS DIFFERENTS DANS UN FICHIER
CALL system('cat SOL_NUMERIQUE/'//OUT_FILE//' >> SOL_NUMERIQUE/U.dat')
CALL system('rm SOL_NUMERIQUE/'//OUT_FILE)
END DO
!A LA FIN, IL RESTE UN FICHIER OU LA SOLUTION EN TEMPS EST SOUS FORME D'INDEX GNUPLOT
!ON APPELLE LA SUBROUTIEN DE VISUALISATION:
CALL VIZU_SOL_NUM(CT)
END IF
End Subroutine CONCAT_VIZU
Subroutine CONCAT_VIZU_ONLY_Nt(sysmove,MINU,MAXU)
Integer, Intent(INOUT):: sysmove
REAL(PR), Intent(IN) :: MINU, MAXU
CHARACTER(LEN=3):: NNT
CHARACTER(LEN=1)::ESPACE
CHARACTER(LEN=20)::NFILE,OUT_FILE
INTEGER::i
!VIZUALISATION SEQUENTIELLE: ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE RANG DIFFERENTS DANS UN FICHIER
IF(rang==0.AND.sysmove==1)THEN
ESPACE=' '
DO i=Nt,Nt
WRITE(NNT,fmt='(1I3)')i;
NFILE='U_ME*'//'_T'//trim(adjustl(NNT));OUT_FILE='UT_'//trim(adjustl(NNT))//'.dat'
!ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE RANG DIFFERENTS DANS UN FICHIER
CALL system('cat SOL_NUMERIQUE/'//NFILE//' >> SOL_NUMERIQUE/'//OUT_FILE)
CALL system('rm SOL_NUMERIQUE/'//NFILE)
OPEN(20,file='SOL_NUMERIQUE/'//OUT_FILE,position='append')
SELECT CASE(CT)!ICI IL FAUT RAJOUTER LES POINTS AUX COINS DU DOMAINES
CASE(1)
WRITE(20,*)0.0d0,0.0d0,0.0d0;WRITE(20,*)Lx,0.0d0,0.0d0
WRITE(20,*)0.0d0,Ly,0.0d0;WRITE(20,*)Lx,Ly,0.0d0
CASE(2)
WRITE(20,*)0.0d0,0.0d0,1.0d0;WRITE(20,*)Lx,0.0d0,1.0d0+sin(Lx)
WRITE(20,*)0.0d0,Ly,cos(Ly);WRITE(20,*)Lx,Ly,cos(Ly)+sin(Lx)
CASE(3)
WRITE(20,*)0.0d0,0.0d0,0.5d0;WRITE(20,*)Lx,0.0d0,0.5d0!TEMPERATURES IMPOSEES DIFFERENTES, ON MOYENNE:((G+H)/2)
WRITE(20,*)0.0d0,Ly,0.5d0;WRITE(20,*)Lx,Ly,0.5d0
END SELECT
WRITE(20,fmt='(1A1)')ESPACE
WRITE(20,fmt='(1A1)')ESPACE
CLOSE(20)
!ON CONCATENE POUR UNE ITERATION EN TEMPS DONNEE, LES FICHIERS DE TEMPS DIFFERENTS DANS UN FICHIER
CALL system('cat SOL_NUMERIQUE/'//OUT_FILE//' >> SOL_NUMERIQUE/U.dat')
CALL system('rm SOL_NUMERIQUE/'//OUT_FILE)
END DO
!A LA FIN, IL RESTE UN FICHIER OU LA SOLUTION EN TEMPS EST SOUS FORME D'INDEX GNUPLOT
!ON APPELLE LA SUBROUTIEN DE VISUALISATION:
!CALL VIZU_SOL_NUM(CT)
CALL VIZU_SOL_NUM_ONLY_Nt(CT,MINU,MAXU)
END IF
End Subroutine CONCAT_VIZU_ONLY_Nt
End Program main
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/DD_Neuman_TRUE_LAST/mod_charge.f90 | module mod_charge
use mod_parametres
Implicit None
CONTAINS
!**************************
!^ y Ny
!|
!|
!|
!1---------> x Nx
!*************************
!SE BASE SUR LA CHARGE EN X POUR CALCULER LA CHARGE TOTALE(GLOBALE)
!INDUIT POUR MOD(DIM,Np)/=0 UNE DIFFERENCE DE CHARGE = A Ny ENTRE 2 PROCS
!UTILISABLE POUR Np<=INTER_X
Subroutine MODE1(rang, Np, S1, S2, it1, itN)
Integer, Intent(IN) :: rang, Np
Integer, Intent(OUT) :: S1, S2,it1, itN
!CHARGE EN X :
CALL CHARGE_X(rang, Np, S1, S2)
!CHARGE TOT :
CALL CHARGE_TOT(S1, S2, it1, itN)
End Subroutine MODE1
!REPARTITION CLASSIQUE DE LA CHARGE EN X
Subroutine CHARGE_X(rang, Np, S1,S2)
Integer, Intent(IN) :: rang, Np
Integer, Intent(OUT) :: S1, S2
REAL :: CO_RE !COEFFICIANT DE REPARTITION
IF(Np == 1)THEN
S1 = 1; S2 = Nx_g
ELSE
CO_RE=(Nx_g)/(Np)
If(rang < mod(Nx_g,Np))Then
S1 = rang*(CO_RE+1) + 1; S2 = (rang+1) * (CO_RE+1)
Else
S1 = 1 + mod(Nx_g,Np) + rang*CO_RE; S2 = S1+CO_RE-1
End If
END IF
End Subroutine CHARGE_X
!CHARGE TOTALE SUR LA NUMEROTATION GLOBALE
Subroutine CHARGE_TOT(S1, S2, it1, itN)
Integer, Intent(IN) :: S1, S2
Integer, Intent(OUT) :: it1, itN
it1 = (S1-1)*Ny_g+1; itN = S2*Ny_g
End Subroutine CHARGE_TOT
!RE-COMPUTE CHARGE WITH OVERLAP
Subroutine CHARGE_OVERLAP(Np, rang, S1, S2, it1, itN)
Implicit None
Integer, Intent(IN) ::Np, rang
Integer, Intent(INOUT) ::S1, S2, it1, itN
!Le (-1) sur overlap pour retirer la frontiere
!immergée qui passe en CL
!WE PUT A Ny_g BECAUSE Ny_l == Ny_g and Ny_l is defined after this subroutine
!Also Because IT'S a 1D DD
!IF WE WANT TO SET UP A 2D DD I WILL NEED DO REPLACE Ny_g BY Ny_l
!AND MAKE OTHER MODIFICATION
IF(rang == 0)THEN
S2 = S2 + (overlap-1)
itN = itN + (overlap-1) * Ny_g
ELSE IF(rang == Np-1)THEN
S1 = S1 - (overlap-1)
it1 = it1 - (overlap-1) * Ny_g
ELSE
S1 = S1 - (overlap-1)
S2 = S2 + (overlap-1)
it1 = it1 - (overlap-1) * Ny_g
itN = itN + (overlap-1) * Ny_g
END IF
End Subroutine CHARGE_OVERLAP
subroutine CHARGE_NEUMAN(it1, itN, rang, Np, S1, S2)
implicit none
Integer, Intent(IN) :: rang, Np
Integer, Intent(INOUT) :: it1, itN, S1, S2
if (rang==0) then
itN = itN+Ny_g
S2=S2+1
else if (rang==Np-1) then
it1 = it1-Ny_g
S1=S1-1
else
it1 = it1-Ny_g
itN = itN+Ny_g
S1=S1-1
S2=S2+1
end if
end subroutine CHARGE_NEUMAN
end module mod_charge
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/DD_Neuman_TRUE_LAST/mod_comm.f90 | module mod_comm
use mpi
use mod_parametres
Implicit None
CONTAINS
Subroutine COMM_PTOP(U,UG,UD)
Real(PR), Dimension(it1:itN), Intent(IN):: U
Real(PR), Dimension(LBUG:UBUG), Intent(INOUT):: UG
Real(PR), Dimension(LBUD:UBUD), Intent(INOUT):: UD
IF(rang == 0)THEN ! rang tag channel
CALL MPI_SEND(U(A:B),2*Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang+1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UD(LBUD:UBUD),2*Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang,MPI_COMM_WORLD,status,stateinfo)
ELSE IF(rang > 0 .AND. rang<Np-1)THEN
CALL MPI_RECV(UG(LBUG:UBUG),2*Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang,MPI_COMM_WORLD,status,stateinfo)
CALL MPI_SEND(U(C:DD),2*Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang-1,MPI_COMM_WORLD,stateinfo)
CALL MPI_SEND(U(A:B),2*Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang+1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UD(LBUD:UBUD),2*Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang,MPI_COMM_WORLD,status,stateinfo)
ELSE IF(rang == Np-1)THEN
CALL MPI_RECV(UG(LBUG:UBUG),2*Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang,MPI_COMM_WORLD,status,stateinfo)
CALL MPI_SEND(U(C:DD),2*Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang-1,MPI_COMM_WORLD,stateinfo)
END IF
End Subroutine COMM_PTOP
Subroutine COMM_PTOP_2WAY(U,UG,UD)
Real(PR), Dimension(it1:itN), Intent(IN):: U
Real(PR), Dimension(LBUG:UBUG), Intent(INOUT):: UG
Real(PR), Dimension(LBUD:UBUD), Intent(INOUT):: UD
IF(rang == 0)THEN ! rang tag channel
CALL MPI_SEND(U(A:B),2*Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang+1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UD(LBUD:UBUD),2*Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang,MPI_COMM_WORLD,status,stateinfo)
ELSE IF(rang > 0 .AND. rang<Pivot)THEN
CALL MPI_RECV(UG(LBUG:UBUG),2*Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang,MPI_COMM_WORLD,status,stateinfo)
CALL MPI_SEND(U(C:DD),2*Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang-1,MPI_COMM_WORLD,stateinfo)
CALL MPI_SEND(U(A:B),2*Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang+1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UD(LBUD:UBUD),2*Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang,MPI_COMM_WORLD,status,stateinfo)
ELSE IF(rang >= Pivot .AND. rang < Np-1)THEN
CALL MPI_RECV(UD(LBUD:UBUD),2*Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang,MPI_COMM_WORLD,status,stateinfo)
CALL MPI_SEND(U(A:B),2*Ny_g,MPI_DOUBLE_PRECISION,rang+1,rang+1,MPI_COMM_WORLD,stateinfo)
CALL MPI_SEND(U(C:DD),2*Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang-1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UG(LBUG:UBUG),2*Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang,MPI_COMM_WORLD,status,stateinfo)
ELSE IF(rang == Np-1)THEN
CALL MPI_SEND(U(C:DD),2*Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang-1,MPI_COMM_WORLD,stateinfo)
CALL MPI_RECV(UG(LBUG:UBUG),2*Ny_g,MPI_DOUBLE_PRECISION,rang-1,rang,MPI_COMM_WORLD,status,stateinfo)
END IF
End Subroutine COMM_PTOP_2WAY
end module mod_comm
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/DD_Neuman_TRUE_LAST/mod_constr_mat.f90 | module mod_constr_mat
use mod_parametres
implicit none
!-->set a_neuman=1.0_PR et b_neuman=0.0000001_PR pour retrouver les mêmes ordres de grandeurs des erreurs L2 qu'avec le sequentiel ou dirichlet
Real(PR), Parameter :: a_neuman = 0.5_PR
Real(PR), Parameter :: b_neuman = 0.5_PR
REAL(PR), Parameter :: c_neuman = a_neuman/b_neuman
Real(PR), Parameter :: alpha_neuman_H = 1._PR -2._PR*beta -2._PR*gamma +((D*dt*a_neuman)/(dx*b_neuman)) +beta
! Les coefficients alpha changent pour les Ny première
! et/ou dernières lignes des matrices dans le cas des CLs de Neuman
Real(PR), Parameter :: alpha_neuman_B = 1._PR -2._PR*beta -2._PR*gamma +((D*dt*a_neuman)/(dx*b_neuman)) +beta
contains
Subroutine L1_NXL_eqv_1(Ny_l,nnz,k,AA,IA,JA)
INTEGER,INTENT(IN)::Ny_l,nnz
INTEGER,INTENT(INOUT)::k
Real(PR), Dimension(nnz), Intent(Out) :: AA
Integer, Dimension(nnz), Intent(Out) :: IA,JA
Integer::d
!ONLY WHEN A PROCES GOT Nx_l==1
DO d = 1, Ny_l
IF(d == 1)THEN
AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
ELSE IF(d>1 .AND. d<Ny_l)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
ELSE IF(d == Ny_l)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
END IF
END DO
End Subroutine L1_NXL_eqv_1
Subroutine L1(Ny_l,nnz,k,AA,IA,JA)
INTEGER,INTENT(IN)::Ny_l,nnz
INTEGER,INTENT(INOUT)::k
Real(PR), Dimension(nnz), Intent(Out) :: AA
Integer, Dimension(nnz), Intent(Out) :: IA,JA
Integer::d,hit
DO d = 1, Ny_l
IF(d == 1)THEN
AA(k)=alpha; IA(k)=d; JA(k)=d
DO hit = d+1, d+Ny_l, Ny_l-1
IF(hit == d+1)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=hit
ELSE
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=hit
END IF
END DO
ELSE IF(d>1 .AND. d<Ny_l)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
ELSE IF(d == Ny_l)THEN
DO hit = d-1, d
IF(hit == d-1)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=hit
ELSE
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=hit
END IF
END DO
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
END IF
END DO
End Subroutine L1
SUBROUTINE TRACK(k,d)
INTEGER,INTENT(INOUT)::k,d
IF(rang==0)THEN
PRINT*,'RANG',rang,'TRACK k,d',k,d
END IF
END SUBROUTINE TRACK
Subroutine L2(Nx_l,Ny_l,nnz,d1,d2,k,AA,IA,JA)
Integer, Intent(IN) :: Nx_l, Ny_l, nnz
Integer, Intent(INOUT) :: d1, d2, k
Real(PR), Dimension(nnz), Intent(Out) :: AA
Integer, Dimension(nnz), Intent(Out) :: IA,JA
INTEGER :: i, d
DO i = 1, Nx_l-2
DO d = d1,d2
IF(d == d1)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
ELSE IF(d>d1 .AND. d<d2)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
ELSE IF(d == d2)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
END IF
END DO
d1 = d2+1; d2=d2+Ny_l
END DO
End Subroutine L2
Subroutine L3(mul1,mul2,Ny_l,nnz,k,AA,IA,JA)
Integer, Intent(IN) :: mul1, mul2, Ny_l, nnz
Integer, Intent(INOUT) :: k
Real(PR), Dimension(nnz), Intent(Out) :: AA
Integer, Dimension(nnz), Intent(Out) :: IA,JA
INTEGER :: d
DO d = mul1, mul2
IF(d == mul1)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
ELSE IF(d>mul1 .AND. d<mul2)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
ELSE IF(d == mul2)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
END IF
END DO
End Subroutine L3
Subroutine L1_Neuman(Ny_l,nnz,k,AA,IA,JA)
IMPLICIT NONE
INTEGER,INTENT(IN)::Ny_l,nnz
INTEGER,INTENT(INOUT)::k
Real(PR), Dimension(nnz), Intent(Out) :: AA
Integer, Dimension(nnz), Intent(Out) :: IA,JA
Integer::d,hit
DO d = 1, Ny_l
IF(d == 1)THEN
AA(k)=alpha_neuman_H
IA(k)=d
JA(k)=d
DO hit = d+1, d+Ny_l, Ny_l-1
IF(hit == d+1)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=hit
ELSE
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=hit
END IF
END DO
ELSE IF(d>1 .AND. d<Ny_l)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha_neuman_H; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
ELSE IF(d == Ny_l)THEN
DO hit = d-1, d
IF(hit == d-1)THEN
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=hit
ELSE
k=k+1; AA(k)=alpha_neuman_H; IA(k)=d; JA(k)=hit
END IF
END DO
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
END IF
END DO
End Subroutine L1_Neuman
Subroutine L3_neuman(mul1,mul2,Ny_l,nnz,k,AA,IA,JA)
IMPLICIT NONE
Integer, Intent(IN) :: mul1, mul2, Ny_l, nnz
Integer, Intent(INOUT) :: k
Real(PR), Dimension(nnz), Intent(Out) :: AA
Integer, Dimension(nnz), Intent(Out) :: IA,JA
INTEGER :: d
DO d = mul1, mul2
IF(d == mul1)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=alpha_neuman_B; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
ELSE IF(d>mul1 .AND. d<mul2)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha_neuman_B; IA(k)=d; JA(k)=d
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
ELSE IF(d == mul2)THEN
k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
k=k+1; AA(k)=alpha_neuman_B; IA(k)=d; JA(k)=d
END IF
END DO
End Subroutine L3_neuman
end module mod_constr_mat
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/DD_Neuman_TRUE_LAST/mod_fonctions.f90 | !---------------------------------------------
! CE MODULE CONTIENT LES FONCTIONS
! DES TERMES SOURCES DE L'EQUATION
!---------------------------------------------
Module mod_fonctions
!---modules-------------------
use mod_parametres
!-----------------------------
Implicit None
Contains
!---fonction f premier exemple(terme source)---
Real(PR) Function f1(CT,x,y,t)
Integer, Intent(In) :: CT
Real(PR), Intent(In) :: x,y,t
f1 = 0.0_PR
If (CT==1) Then
f1=2._PR*(y*(1._PR-y)+x*(1._PR-x))
Else IF (CT==2) Then
f1=sin(x)+cos(y)
Else If (CT==3) Then
f1=exp(-((x-(Lx/2._PR))**2._PR))*exp(-((y-(Ly/2._PR))**2._PR))&
*cos((pi/2._PR)*t)
End If
End Function f1
!----------------------------------------------
!---fonction g premier exemple( bords haut/bas)-
Real(PR) Function g1(CT,x,y,t)
Integer, Intent(In) :: CT
Real(PR), Intent(In) :: x,y,t
g1 = 0.0_PR
If (CT==1) Then
g1=0._PR
Else IF (CT==2) Then
g1=sin(x)+cos(y)
Else If (CT==3) Then
g1=0._PR
End If
End Function g1
!----------------------------------------------
!---function h premier exemple(bord gauche/droite)
Real(PR) Function h1(CT,x,y,t)
Integer, Intent(In) :: CT
Real(PR), Intent(In) :: x,y,t
h1 = 0.0_PR
If (CT==1) Then
h1=0._PR
Else IF (CT==2) Then
h1=sin(x)+cos(y)
Else If (CT==3) Then
h1=1._PR
End If
End Function h1
!---Fonctions donnant les vecteurs Xi,Yj,Tn---------------
Subroutine param(X,Y,T)
Implicit None
!---variables-------------------------
real(PR), Dimension(:), Allocatable, Intent(InOut) :: X
real(PR), Dimension(:), Allocatable, Intent(InOut) :: Y
real(PR), Dimension(:), Allocatable, Intent(InOut) :: T
Integer :: i
!-------------------------------------
ALLOCATE(Y(0:Ny_g+1),T(0:Nt+1),X(0:Nx_g+1))
Do i=0,Ny_g+1
Y(i)=i*dy
End Do
Do i=0,Nt+1
T(i)=i*nt
End Do
DO i=0,Nx_g+1
X(i)=i*dx
END DO
!SET VARIABLES SIZE USED MANY TIMES
!FOR x VECTOR:
LBX = lbound(X,1) ; UBX = ubound(X,1)
!FOR UD AND UG VECTORS TO RECV:
LBUD = itN+1-2*Ny_g ; UBUD = itN
LBUG = it1 ; UBUG = it1-1+2*Ny_g
!FOR VECTOR SIZE TO SEND:
A = (itN - 2*overlap*Ny_g) +1; B = A + 2*Ny_g -1
DD = (it1 + 2*overlap*Ny_g) -1; C = DD - 2*Ny_g +1
End Subroutine param
Subroutine param_para(rang,Np,S1,S2,Ny_l,X,Y,T)
Implicit None
!---variables-------------------------
Integer, Intent(IN) :: rang, Np, S1, S2, Ny_l
real(PR), Dimension(:), Allocatable, Intent(InOut) :: X
real(PR), Dimension(:), Allocatable, Intent(InOut) :: Y
real(PR), Dimension(:), Allocatable, Intent(InOut) :: T
Integer :: i
!-------------------------------------
ALLOCATE(Y(0:Ny_l+1),T(0:Nt+1))
Do i=0,Ny_l+1
Y(i)=i*dy
End Do
Do i=0,Nt+1
T(i)=i*nt
End Do
IF(rang == 0)THEN
ALLOCATE(X(S1-1:S2))
Do i=S1-1,S2
X(i)=i*dx
End Do
ELSE IF(rang == Np-1)THEN
ALLOCATE(X(S1:S2+1))
DO i=S1,S2+1
X(i)=i*dx
END DO
ELSE
ALLOCATE(X(S1:S2))
DO i=S1,S2
X(i)=i*dx
END DO
END IF
!SET VARIABLES SIZE USED MANY TIMES
!FOR x VECTOR:
LBX = lbound(X,1) ; UBX = ubound(X,1)
!FOR UD AND UG VECTORS TO RECV:
LBUD = itN+1-2*Ny_g ; UBUD = itN
LBUG = it1 ; UBUG = it1-1+2*Ny_g
!FOR VECTOR SIZE TO SEND:
A = (itN - 2*overlap*Ny_g) +1; B = A + 2*Ny_g -1
DD = (it1 + 2*overlap*Ny_g) -1; C = DD - 2*Ny_g +1
End Subroutine param_para
!-------------------------------------------------------------
End Module mod_fonctions
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/DD_Neuman_TRUE_LAST/mod_gmres.f90 | module mod_gmres
USE mod_parametres
USE mod_fonctions
Implicit None
Contains
!---FONCTION PRODUIT MATxVEC EN SPARSE-------------------------
Function MatVecSPARSE(AA,IA,JA,x) Result(y)
Implicit None
!Produit MatriceSPARSE.vecteur plein (x) retourne vecteur plein(y)
!---variables------------------------------------------
Real(PR), Dimension(:), Intent(In) :: AA,x
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(Size(x)) :: y
Integer :: i,n,nnz
!--------------------------------------------------------
n=Size(x,1)
nnz=Size(AA,1)
y(1:n)=0._PR
Do i=1,nnz
if (IA(i)==0) then
!print*,"element IA nul pour i =",i
end if
y(IA(i))=y(IA(i))+AA(i)*x(JA(i))
End Do
End Function MatVecSPARSE
!---------------------------------------------------------------
!---FONCTION PRODUIT MATxVEC EN SPARSE-------------------------
Function COL_MatVecSPARSE(AA,IA,JA,x,dim) Result(y)
Implicit None
!Produit MatriceSPARSE.vecteur plein (x) retourne vecteur plein(y)
!---variables------------------------------------------
Integer, Intent(IN) :: dim
Real(PR), Dimension(:), Intent(In) :: AA
Real(PR), Dimension(1:dim,1), Intent(In) :: x
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(dim) :: y
Integer :: i,nnz
!--------------------------------------------------------
!n=Size(x,1)
nnz=Size(AA,1)
y(1:dim)=0._PR
Do i=1,nnz
if (IA(i)==0) then
!print*,"element IA nul pour i =",i
end if
y(IA(i))=y(IA(i))+AA(i)*x(JA(i),1)
End Do
End Function COL_MatVecSPARSE
!---------------------------------------------------------------
Subroutine GMres_COO(AA,IA,JA,f,x0,x,b,k,dim,it1,itN,DIMKRYLOV)
Implicit None
!-----Variables: dim = Na_l
Integer, Intent(IN) :: dim, it1, itN, DIMKRYLOV
Real(PR), Dimension(:), Intent(In) :: AA
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(it1:itN), Intent(In) :: f,x0 !f=vect source , x0=CI
Real(PR), Dimension(it1:itN), Intent(InOut) :: x !solution finale
Real(PR), Intent(Out) :: b !norme du résidu
Integer, Intent(Out) :: k !nb d'itérations pour convergence
Integer :: m ! m = DIMKRYLOV
Integer :: kmax !nb d'itérations max
Real(PR) ::beta !norm2 de r
Real(PR) :: eps !tol solver
! Rescale: Bufferx(1:dim) = x(it1:itN) so natural dot_product
Real(PR), Dimension(:), Allocatable :: Bufferx0, Bufferx, Bufferf
!---- Vectors & Matrix used for GMres:
Real(PR),dimension(1:dim,1:DIMKRYLOV+1)::Vm
!Real(PR),dimension(1:m+1,1:m)::Hm_
Real(PR),dimension(:,:),allocatable::Hm_
Real(PR),dimension(1:DIMKRYLOV+1,1:DIMKRYLOV)::Rm_
Real(PR),dimension(1:DIMKRYLOV+1,1:DIMKRYLOV+1)::Qm_
Real(PR),dimension(1:dim,1:DIMKRYLOV)::FF !Vm+1.Hm_
Real(PR),dimension(1:DIMKRYLOV+1)::gm_
Real(PR),dimension(1:DIMKRYLOV)::y !sol de Rm.y=gm
Real(PR),dimension(1:dim)::Vmy
Real(PR),dimension(1:dim)::AX
Real(PR),dimension(1:dim)::z,p,r
Allocate(Bufferx0(1:itN-it1+1))
Bufferx0(1:dim) = x0(it1:itN)
Allocate(Bufferx(1:itN-it1+1))
Bufferx(1:dim) = x(it1:itN)
Allocate(Bufferf(1:itN-it1+1))
Bufferf(1:dim) = f(it1:itN)
m = DIMKRYLOV
beta=0.0_PR
k=0
!**INITIALISATION DE ro=b-AXo:MatVecSPARSE(AA,IA,JA,x)
r=Bufferf-MatVecSPARSE(AA,IA,JA,Bufferx0)
beta = DOT_PRODUCT(r,r)
beta = sqrt(beta)
eps = 0.00001_PR
kmax = dim**2
boucle_eps_kmax:DO WHILE(beta>eps .AND. k<kmax)
!Construction DE LA BASE Vm et de Hm_
ALLOCATE(Hm_(1:m+1,1:m))
CALL arnoldi_reortho(dim,m,AA,IA,JA,r,beta,Vm,Hm_)
!Decomposion QR de Hm_ pour avoir Qm_ et Rm_
Rm_ = Hm_
DEALLOCATE(Hm_)
CALL givens_QR_opt2(dim,m,Rm_,Qm_)
!CALL givens_QR_opt(dim,m,Hm_,Qm_,Rm_)
!Setup gm_ = transpose(Qm_). beta*e1
gm_LOOP:DO i = 1,m+1
gm_(i) = beta * Qm_(1,i)
END DO gm_LOOP
!Resolution DE Rm.y=gm où Rm=Rm_(1:m,:)et gm= gm_(1:m)
y(m)=gm_(m)/Rm_(m,m)
moindrecarre:do j=m-1,1,-1
y(j)=gm_(j)
do c=j+1,m
y(j)=y(j)-Rm_(j,c)*y(c)
end do
y(j)=y(j)/Rm_(j,j)
end do moindrecarre
!Calcul de Vmy
Vmy=MATMUL(Vm(1:dim,1:m),y)
!CALCUL de X=X+Vm.y
Bufferx=Bufferx+Vmy
!Actualisation r:
r=bufferf-MatVecSPARSE(AA,IA,JA,Bufferx)
beta=sqrt(DOT_PRODUCT(r,r))
k=k+1
! PRINT*,'APRES k=k+1',k,beta
if(rang==0)then
print*,'gmres rang,k,res',rang,k,beta
end if
END DO boucle_eps_kmax
b = beta
x(it1:itN) = Bufferx(1:dim)
Deallocate(Bufferx0,Bufferx,Bufferf)
End Subroutine GMres_COO
!----------
!$$$$$$$$$$$$$$$$ARNOLDI MGS REORTHO$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
subroutine arnoldi_reortho(dim,m,AA,IA,JA,ro,beta,Vm,Hm_)!v,Vm,Hm_)
Implicit None
!la notation Hm_ pour la barre up du Hm correspondant
!à la notation theorique
!m nbr de colonne de Vm ; Vm appartient à M_n,m(R), n =dim ici
integer,intent(in)::dim,m
!on utilise m pour fixer la dimension de Vm,
!base constituée des (vi)i
Real(PR),dimension(1:dim),intent(in)::ro
Real(PR),intent(in)::beta
!ro=b-Axo
!beta =||ro|| au carré
!Real(PR),dimension(1:dim),intent(inout)::v
!v vecteur constituant les colonnes de Vm
Real(PR), Dimension(:), Intent(In) :: AA
Integer, Dimension(:), Intent(In) :: IA,JA
!Real(PR),dimension(1:dim,1:dim),intent(in)::A
Real(PR),dimension(1:dim,1:m+1),intent(out)::Vm
Real(PR),dimension(1:m+1,1:m),intent(out)::Hm_
Real(PR),dimension(1:dim)::z,Av
!z vecteur de stockage pour calcul de v
!Av pour stocker A.v_j ,v_j la colonne de Vm
Real(PR)::pscal,nz,tmp !nz pour calculer la norme de z
integer::k,i,j,c,d
!**INITIALISATION DE v:
Vm=0.0_PR
Hm_=0.0_PR
!v=ro/beta !v1
do i=1,dim
Vm(i,1)=ro(i)/beta
end do
!**CALCUL DE z:
j=0
do while(j<m)
j=j+1
!$$CALCUL DE A.v:
Av=0.0_PR
Av = Av + COL_MatVecSPARSE(AA,IA,JA,Vm(1:dim,j),dim)
z=Av
do i=1,j
!$$CALCUL DE SUM(<Avj|vi>.vi)
pscal=0.0_PR
pscal=DOT_PRODUCT(Av,Vm(1:dim,i))
Hm_(i,j)=pscal
z=z-Hm_(i,j)*Vm(:,i)
end do!fin do i
!$$$$$REORTHO
do i=1,j!j
tmp=0.0_PR
tmp=DOT_PRODUCT(z,Vm(:,i))
z=z-tmp*Vm(:,i)
Hm_(i,j)=Hm_(i,j)+tmp
end do
!$$CALCUL DE ||z||:
nz=0.0_PR
nz=DOT_PRODUCT(z,z)
nz=sqrt(nz)
Hm_(j+1,j)=nz
!$$CONDITION ARRET HEUREUX:
if(abs(Hm_(j+1,j))<0.00000001_PR)then
j=m+1!stop
else !end if
!$$FIN CONDITION ARRET HEUREUX
!$$ACTUALISATION/CALCUL DE Vm(:,j+1); v_(j+1) la j+1 ieme cows de Vm
Vm(:,j+1)=z !/Hm_(j+1,j)
Vm(:,j+1)=Vm(:,j+1)/nz
end if
! PRINT*,'MGS_REORTHO',j
end do
end subroutine arnoldi_reortho
subroutine givens_QR_opt2(dim,m,Rm_,Qm_)!Hm_,Qm_,Rm_)
Implicit None
integer,intent(in)::dim,m
!real,dimension(1:m+1,1:m),intent(in)::Hm_
Real(PR),dimension(1:m+1,1:m),intent(inout)::Rm_
Real(PR),dimension(1:m+1,1:m+1),intent(out)::Qm_
Real(PR)::c,s
Real(PR)::coef1,coef2,coef_a,coef_b
Real(PR)::TQ1,TQ2,TQ3,TQ4
Real(PR)::Qg,Qd
integer::i,j,k,l
!Rm_=Hm_
Qm_=0.0_PR
do i=1,m+1
Qm_(i,i)=1.0_PR!?stock_T_Qm_(i,i)=1.
end do
do j=1,m!-1!m
do l=j+1,j+1,-1!m+1,j+1,-1 !DE j+1 à j+1 car Hm_ forme de Hessenberg
coef1=Rm_(l,j);coef2=Rm_(l-1,j)
c=coef1*coef1+coef2*coef2;c=sqrt(c)
s=c
c=coef2/c;s=-coef1/s
TQ1=c !T_Qm_(l,l)=c
TQ2=c !T_Qm_(l-1,l-1)=c
TQ3=-s !T_Qm_(l-1,l)=-s
TQ4=s !T_Qm_(l,l-1)=s
do k=j,m
coef_a=Rm_(l-1,k);coef_b=Rm_(l,k)
Rm_(l-1,k)=c*coef_a-s*coef_b
Rm_(l,k)=s*coef_a+c*coef_b
end do
Rm_(l,j)=0.0_PR
TQ3=-TQ3
TQ4=-TQ4
if(j==1 .AND. l==j+1)then
Qm_(l,l)=TQ1;Qm_(l-1,l-1)=TQ2;Qm_(l-1,l)=TQ3;Qm_(l,l-1)=TQ4
else
do i=1,m+1
Qg=Qm_(i,l-1);Qd=Qm_(i,l)
Qm_(i,l-1)=Qg*TQ2+Qd*TQ4
Qm_(i,l)=Qg*TQ3+Qd*TQ1
end do
end if
end do !fin do l
! PRINT*,'GIVENS',j
end do !fin do j
end subroutine givens_QR_opt2
end module mod_gmres
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/DD_Neuman_TRUE_LAST/mod_gradconj.f90 | !-----------------------------------------
! CE MODULE CONTIENT LE GRADIENT CONJUGUÉ
! EN PLEIN ET EN CREUX (FORMAT COORDONNES)
!-----------------------------------------
Module mod_gradconj
!---modules----------------
use mod_parametres
use mod_fonctions
!--------------------------
Implicit None
Contains
!---GRADIENT CONJUGUÉ POUR UNE MATRICE A PLEINE---------
Subroutine gradconj(A,b,x0,x,beta,k,n)
!---variables------------------------------------
Integer, Intent(In) :: n !taille vecteur solution (=taille de la matrice carrée)
Real(PR), Dimension(:,:), Intent(In) :: A !matrice à inverser
Real(PR), Dimension(:), Intent(In) :: b,x0 ! b second membre, x0 CI
Real(PR), Dimension(:), Intent(Out) :: x !solution finale
Real(PR), Intent(Out) :: beta !norme du résidu
Real(PR), Dimension(:), Allocatable :: p,z,r1,r2
Real(PR) :: alpha,gamma,eps
Integer, Intent(Out) :: k !nb d'itération pr convergence
Integer :: kmax
!-------------------------------------------------
eps=0.01_PR
kmax=150
Allocate(p(n),z(n),r1(n),r2(n))
r1=b-matmul(A,x0)
p=r1
beta=sqrt(sum(r1*r1))
k=0
Do While (beta>eps .and. k<=kmax)
z=matmul(A,p)
alpha=dot_product(r1,r1)/dot_product(z,p)
x=x+alpha*p
r2=r1-alpha*z
gamma=dot_product(r2,r2)/dot_product(r1,r1)
p=r2+gamma*p
beta=sqrt(sum(r1*r1))
k=k+1
r1=r2
End Do
If (k>kmax) then
Print*,"Tolérance non atteinte:",beta
End If
Deallocate(p,z,r1,r2)
End Subroutine gradconj
!----------------------------------------------------
!---GRADIENT CONJUGUÉ POUR MATRICE CREUSE AU FORMAT COORDONNÉES-----
!---A PARALLELISER : PRODUIT MATRICE/VECTEUR + PRODUIT SCALAIRE
Subroutine gradconj_SPARSE(AA,IA,JA,F,x0,x,b,k,n)
Implicit None
!---variables ---------------------------------------
Integer, Intent(In) :: n !taille vecteur solution
Real(PR), Dimension(:), Intent(In) :: AA
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(:), Intent(In) :: f,x0 !f=vect source , x0=CI
Real(PR), Dimension(:), Intent(InOut) :: x !solution finale
Real(PR), Intent(Out) :: b !norme du résidu
Real(PR), Dimension(:), Allocatable :: p,z,r1,r2
Real(PR) :: a,g,eps
Integer, Intent(Out) :: k !nb d'itérations pour convergence
Integer :: kmax !nb d'itérations max
!-----------------------------------------------------
eps=0.01_PR
kmax=1500
Allocate(p(n),z(n),r1(n),r2(n))
!---paralléliser------------------------
r1=f-MatVecSPARSE(AA,IA,JA,x0)
!-------------------------------------
p=r1
b=sqrt(sum(r1*r1))
k=0
Do While (b>eps .and. k<=kmax)
!---paralléliser------------------
z=MatVecSPARSE(AA,IA,JA,p)
!---------------------------------
a=dot_product(r1,r1)/dot_product(z,p)
x=x+a*p
r2=r1-a*z
g=dot_product(r2,r2)/dot_product(r1,r1)
p=r2+g*p
b=sqrt(sum(r1*r1))
k=k+1
r1=r2
End Do
If (k>kmax) then
Print*,"Tolérance non atteinte:",b
End If
Deallocate(p,z,r1,r2)
End Subroutine gradconj_SPARSE
!--------------------------------------------------------------
!---FONCTION PRODUIT MATxVEC EN SPARSE-------------------------
Function MatVecSPARSE(AA,IA,JA,x) Result(y)
!Produit MatriceSPARSE.vecteur plein (x) retourne vecteur plein(y)
!---variables------------------------------------------
Real(PR), Dimension(:), Intent(In) :: AA,x
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(Size(x)) :: y
Integer :: i,n,nnz
!--------------------------------------------------------
n=Size(x,1)
nnz=Size(AA,1)
y(1:n)=0._PR
Do i=1,nnz
if (IA(i)==0) then
print*,"element IA nul pour i =",i
end if
y(IA(i))=y(IA(i))+AA(i)*x(JA(i))
End Do
End Function MatVecSPARSE
!---------------------------------------------------------------
!GC COO FORMAT BUILD FOR global numerotation over x
Subroutine MOD_gradconj_SPARSE(AA,IA,JA,f,x0,x,b,k,it1,itN)
Implicit None
!---variables ---------------------------------------
Integer, Intent(In) :: it1,itN !taille vecteur solution
Real(PR), Dimension(:), Intent(In) :: AA
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(it1:itN), Intent(In) :: f,x0 !f=vect source , x0=CI
Real(PR), Dimension(it1:itN), Intent(InOut) :: x !solution finale
Real(PR), Intent(Out) :: b !norme du résidu
Real(PR), Dimension(:), Allocatable :: p,z,r1,r2
Real(PR) :: a,g,eps
Integer, Intent(Out) :: k !nb d'itérations pour convergence
Integer :: kmax !nb d'itérations max
!-----------------------------------------------------
eps=0.000001_PR
kmax=1500
Allocate(p(it1:itN),z(it1:itN),r1(it1:itN),r2(it1:itN))
!---paralléliser------------------------
r1=f-MOD_MatVecSPARSE(AA,IA,JA,x0,it1,itN)
!-------------------------------------
p=r1
b=sqrt(sum(r1*r1))
k=0
Do While (b>eps .and. k<=kmax)
!---paralléliser------------------
z=MOD_MatVecSPARSE(AA,IA,JA,p,it1,itN)
!---------------------------------
a=dot_product(r1,r1)/dot_product(z,p)
x=x+a*p
r2=r1-a*z
g=dot_product(r2,r2)/dot_product(r1,r1)
p=r2+g*p
b=sqrt(sum(r1*r1))
k=k+1
r1=r2
!PRINT*,'k,b',k,b
End Do
If (k>kmax) then
Print*,"Tolérance non atteinte:",b
End If
Deallocate(p,z,r1,r2)
End Subroutine MOD_gradconj_SPARSE
!--------------------------------------------------------------
!---FONCTION PRODUIT MATxVEC EN SPARSE-------------------------
Function MOD_MatVecSPARSE(AA,IA,JA,x,it1,itN) Result(y)
!Produit MatriceSPARSE.vecteur plein (x) retourne vecteur plein(y)
!---variables------------------------------------------
INTEGER,INTENT(IN)::it1,itN
Real(PR), Dimension(:), Intent(In) :: AA
Real(PR), Dimension(it1:itN), Intent(In) ::x
Integer, Dimension(:), Intent(In) :: IA,JA
Real(PR), Dimension(it1:itN) :: y
Integer :: i,n,nnz,val
!--------------------------------------------------------
n=Size(x,1)
!PRINT*,'***',n,itN-it1+1
nnz=Size(AA,1)
y(it1:itN)=0._PR
val=(it1-1)
Do i=1,nnz
if (IA(i)==0) then
print*,"element IA nul pour i =",i
end if
!PRINT*,i,IA(i),val+IA(i),JA(i),val+JA(i),x(val+JA(i))
y(val+IA(i))=y(val+IA(i))+AA(i)*x(val+JA(i))
End Do
End Function MOD_MatVecSPARSE
!---------------------------------------------------------------
Subroutine MOD_jacobi_SPARSE(AA,IA,JA,F,x0,x,resnorm,k)
!-----variables---------------------
Real(PR), Dimension(nnz_l), Intent(In) :: AA
Integer, Dimension(nnz_l), Intent(In) :: IA,JA
Real(PR), Dimension(it1:itN), Intent(InOut) :: F,x0 !f=vect source , x0=CI
Real(PR), Dimension(it1:itN), Intent(InOut) :: x !solution finale
Real(PR), Intent(Out) :: resnorm !norme du résidu
Real(PR), Dimension(:), Allocatable :: r
Real(PR) :: eps,somme
Integer, Intent(InOut) :: k !nb d'itérations pour convergence
Integer :: kmax,pp,val,ii,borne !nb d'itérations max
ALLOCATE(r(it1:itN))
borne=nnz_l+1
x=x0
eps = 0.000001_PR
kmax = 100000
r = F-MOD_MatVecSPARSE(AA,IA,JA,x0,it1,itN) !résidu initial
resnorm = sqrt(sum(r*r)) !norme 2 du résidu
k = 0 !initialisation itération
boucle_resolution: Do While ((resnorm>eps) .and. (k<kmax))
k=k+1
!on calcule xi^k+1=(1/aii)*(bi-sum(j=1,n;j/=i)aij*xj^k)
x0=0._PR
pp=1;val=it1-1
boucle_xi: Do ii=1,Na_l
!calcul de la somme des aij*xj^k pour j=1,n;j/=i
somme = 0.0_PR;
!!$ if(rang==0)then
!!$ PRINT*,'ii,pp,k,nnz_l,ubound IA',ii,pp,k,nnz_l,ubound(IA,1),nnz_l+1
!!$ end if
DO WHILE((pp<borne) .AND. (ii==IA(pp)))
IF (IA(pp) /= JA(pp)) THEN
somme= somme + x(val+JA(pp)) * AA(pp)
END IF
!!$ if(rang==0)then
!!$ PRINT*,'ii,pp,IA(pp),JA(pp),AA(pp),x(JA(pp))',ii,pp,IA(pp),JA(pp),AA(pp),x(val+JA(pp))
!!$ end if
pp=pp+1
!PRINT*,'pp',pp
if(pp==borne)then !because the do while check both pp<borne and ii==IA(pp),maybe due to makefile
! he should break when pp>=borne and don't check ii==IA(pp)
GOTO 7777
end if
END DO
!calcul du nouveau xi
7777 x0(val+ii)=(1._PR/alpha)*(F(val+ii)-somme)
x0(val+ii)=(1._PR/alpha)*(F(val+ii)-somme)!;print*,'t',rang
End Do boucle_xi
x=x0
!on calcule le nouveau résidu
r = F - MOD_MatVecSPARSE(AA,IA,JA,x,it1,itN)
! calcul de la norme 2 du résidu
resnorm = sqrt(sum(r*r))
if(mod(k,1000)==0)then
print*,resnorm,k
end if
End Do boucle_resolution
If (k>kmax) then
Print*,"Tolérance non atteinte:",resnorm
End If
DEALLOCATE(r)
print*,"converge avec eps=",resnorm
End Subroutine MOD_jacobi_SPARSE
subroutine BICGSTAB(it1, itN, AA, IA, JA, x, b, eps)
implicit none
Integer, Intent(IN) :: it1, itN
real(PR), dimension(:), intent(In) :: AA
integer, dimension(:), intent(In) :: IA, JA
real(PR), dimension(it1:itN), intent(InOut) :: x
real(PR), dimension(it1:itN), intent(In) :: b
real(PR), intent(In) :: eps
real(PR), dimension(it1:itN) :: r0, v, p, r, h, s, t
real(PR) :: rho_i, rho_im1, alpha_CG, omega, w, beta_CG
Real(PR) :: beta_res
integer :: kmax
integer :: k
omega = 1.0_PR
!x = 0._PR
r0 = b - MOD_MatVecSPARSE(AA,IA,JA,x,it1,itN)
r = r0
beta_res = SQRT(DOT_PRODUCT(r0,r0))
rho_im1 = 1._PR; alpha_CG = 1._PR; w = 1._PR
v = 0._PR; p = 0._PR
k = 0
kmax = 2*Na_l*Na_l
!do while((maxval(abs(r))>eps) .and. (k<kmax))
do while( beta_res >eps .and. (k<kmax) )
rho_i = dot_product(r0, r)
beta_CG = (rho_i/rho_im1)*(alpha_CG/w)
p = r+beta_CG*(p-v*w)
v = MOD_MatVecSPARSE(AA,IA,JA,p,it1,itN)
alpha_CG = rho_i/dot_product(r0, v)
h = x+p*alpha_CG
s = r-v*alpha_CG
t = MOD_MatVecSPARSE(AA,IA,JA,s,it1,itN)
w = dot_product(t, s)/dot_product(t, t)
x = h+s*w
r = s-t*w
beta_res = SQRT(DOT_PRODUCT(r,r))
rho_im1 = rho_i
k = k+1
end do
!PRINT*,'RESIDU=',maxval(abs(r))
end subroutine BICGSTAB
End Module mod_gradconj
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/DD_Neuman_TRUE_LAST/mod_matsys.f90 | !----------------------------------------------------
! CE MODULE CONTIENT LA CONSTRUCTION DE LA MATRICE A
! ET LE VECTEUR SOURCE F
!----------------------------------------------------
Module mod_matsys
!---modules-------------------
Use mod_parametres
Use mod_fonctions
Use mod_gradconj
Use mod_constr_mat
!-----------------------------
Implicit None
Contains
!--- SUBROUTINE QUI CONSTRUIT LA MATRICE A : UN SEUL APPEL ----------------------
Subroutine matsys_v2(nnz,Nx_l,Ny_l,AA,IA,JA)
Integer, Intent(IN) ::nnz,Nx_l,Ny_l
Real(PR), Dimension(:), Allocatable, Intent(Out) :: AA
Integer, Dimension(:), Allocatable, Intent(Out) :: IA,JA
Integer :: k, mul2, d1, d2, mul1
k = 1; mul2 = Nx_l*Ny_l; mul1 = Ny_l*(Nx_l-1)+1
ALLOCATE(AA(nnz),IA(nnz),JA(nnz))
!L1-----------------------------------------------------------
IF(Nx_l > 1)THEN
if (rang/=0) then
CALL L1_neuman(Ny_l,nnz,k,AA,IA,JA)
else
CALL L1(Ny_l,nnz,k,AA,IA,JA)
end if
!CRTL nnz_L1
IF(k /= crtl_L1_nnz)THEN
PRINT*,'ERROR L1_nnz','RANG',rang,'k_L1',k,'/=','crtl_L1_nnz',crtl_L1_nnz
AA=0._PR;IA=0;JA=0
END IF
ELSE IF(Nx_l == 1)THEN
CALL L1_NXL_eqv_1(Ny_l,nnz,k,AA,IA,JA)
IF(k /= crtl_L1_nnz_Nxl_EQV_1)THEN
PRINT*,'ERROR L1_nnz','RANG',rang,'k_L1',k,'/=','crtl_L1_nnz_Nxl_EQV_1',crtl_L1_nnz_Nxl_EQV_1
AA=0._PR;IA=0;JA=0
END IF
END IF
!L2-----------------------------------------------------------
IF(Nx_l>2)THEN
d1 = Ny_l+1; d2 = 2*Ny_l
CALL L2(Nx_l,Ny_l,nnz,d1,d2,k,AA,IA,JA)
IF(k /= crtl_L1_nnz + crtl_L2_nnz)THEN
PRINT*,'ERROR L2_nnz','RANG',rang,'k_L2',k-crtl_L1_nnz,'/=','crtl_L2_nnz',crtl_L2_nnz
AA=0._PR;IA=0;JA=0
END IF
END IF
!L3-----------------------------------------------------------
IF(Nx_l>1)THEN
if (rang/=Np-1) then
CALL L3_neuman(mul1,mul2,Ny_l,nnz,k,AA,IA,JA)
else
CALL L3(mul1,mul2,Ny_l,nnz,k,AA,IA,JA)
end if
PRINT*,'rang',rang,'k',k,'FIN L3'
IF(k /= sum_crtl_L_nnz)THEN
PRINT*,'ERROR L3_nnz','RANG',rang,'k_L3',k-crtl_L1_nnz-crtl_L2_nnz,'/=','crtl_L3_nnz',crtl_L3_nnz
AA=0._PR;IA=0;JA=0
END IF
END IF
END Subroutine matsys_v2
!--------SUBROUTINE DU VECTEUR SOURCE EN FONCTION DE L'ITERATION N ET DU VECTEUR U--------
Subroutine vectsource(CT,U,S1,S2,X,Y,T,F)
Implicit None
!---variables----------------------------------
Integer, Intent(In) :: CT, S1, S2
Real(PR), Dimension(it1:itN), Intent(In) :: U
Real(PR), Dimension(LBX:UBX), Intent(IN) :: X
Real(PR), Dimension(0:Ny_g+1), Intent(IN) :: Y !BECAUSE DD 1D => Ny_l == Ny_g
Real(PR), Intent(IN) :: T
Real(PR), Dimension(it1:itN), Intent(INOUT) :: F
Integer :: i,j,k
DO i = S1, S2
DO j = 1, Ny_g
k = j + (i-1)*Ny_g
F(k) = dt * f1(CT,X(i),Y(j),T)
IF(i == 1)THEN
F(k) = F(k) - h1(CT,X(i-1),Y(j),T)*beta
ELSE IF(i == Nx_g)THEN
F(k) = F(k) - h1(CT,X(i+1),Y(j),T)*beta
END IF
IF(j == 1)THEN
F(k) = F(k) - g1(CT,X(i),Y(j-1),T)*gamma
ELSE IF(j == Ny_g)THEN
F(k) = F(k) - g1(CT,X(i),Y(j+1),T)*gamma
END IF
END DO
END DO
F = F +U
End Subroutine vectsource
Subroutine vectsource_FULL(CT,U,UG,UD,S1,S2,X,Y,T,F)
Implicit None
!---variables----------------------------------
Integer, Intent(In) :: CT, S1, S2
Real(PR), Dimension(it1:itN), Intent(In) :: U
Real(PR), Dimension(LBUG:UBUG), Intent(In) :: UG
Real(PR), Dimension(LBUD:UBUD), Intent(In) :: UD
Real(PR), Dimension(LBX:UBX), Intent(IN) :: X
Real(PR), Dimension(0:Ny_g+1), Intent(IN) :: Y !BECAUSE DD 1D => Ny_l == Ny_g
Real(PR), Intent(IN) :: T
Real(PR), Dimension(it1:itN), Intent(INOUT) :: F
Integer :: i,j,k
DO i = S1, S2
DO j = 1, Ny_g
k = j + (i-1)*Ny_g
F(k) = dt * f1(CT,X(i),Y(j),T)
IF(i == 1)THEN
F(k) = F(k) - h1(CT,X(i-1),Y(j),T)*beta
ELSE IF(i == S1 )THEN !.AND. rang /= 0)THEN not needed with the current order if... else if
F(k) = F(k) + (D*dt/dx)*UG(k)*c_neuman + beta*( UG(k+Ny_g)-UG(k) )
ELSE IF(i == Nx_g)THEN
F(k) = F(k) - h1(CT,X(i+1),Y(j),T)*beta
ELSE IF(i == S2)THEN !.AND. rang /= Np-1)THEN not needed with the current order else if... else if
F(k) = F(k) + (D*dt/dx)*UD(k)*c_neuman + beta*( UD(k-Ny_g)-UD(k) )
END IF
IF(j == 1)THEN
F(k) = F(k) - g1(CT,X(i),Y(j-1),T)*gamma
ELSE IF(j == Ny_g)THEN
F(k) = F(k) - g1(CT,X(i),Y(j+1),T)*gamma
END IF
END DO
END DO
F = F +U
End Subroutine vectsource_FULL
End Module mod_matsys
!!$DO d = 1, Ny_l
!!$ IF(d == 1)THEN
!!$ AA(k)=alpha; IA(k)=d; JA(k)=d
!!$ DO hit = d+1, d+Ny_l, Ny_l-1
!!$ IF(hit == d+1)THEN
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=hit
!!$ ELSE
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=hit
!!$ END IF
!!$ END DO
!!$ ELSE IF(d>1 .AND. d<Ny_l)THEN
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
!!$ k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
!!$ ELSE IF(d == Ny_l)THEN
!!$ DO hit = d-1, d
!!$ IF(hit == d-1)THEN
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=hit
!!$ ELSE
!!$ k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=hit
!!$ END IF
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
!!$ END DO
!!$ END IF
!!$ END DO
!!$IF(Nx_l>2)THEN
!!$ d1 = Ny_l+1; d2 = 2*Ny_l
!!$ DO i = 1, Nx_l-2
!!$ DO d = d1,d2
!!$ IF(d == d1)THEN
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
!!$ k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
!!$ ELSE IF(d>d1 .AND. d<d2)THEN
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
!!$ k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d+1
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
!!$ ELSE IF(d == d2)THEN
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d-Ny_l
!!$ k=k+1; AA(k)=gamma; IA(k)=d; JA(k)=d-1
!!$ k=k+1; AA(k)=alpha; IA(k)=d; JA(k)=d
!!$ k=k+1; AA(k)=beta; IA(k)=d; JA(k)=d+Ny_l
!!$ END IF
!!$ END DO
!!$ d1 = d2+1; d2=d2+Ny_l
!!$ END DO
!!$ END IF
!!$Subroutine matsys(nnz,AA,IA,JA)
!!$ Integer, Intent(In) :: nnz
!!$ Real(PR), Dimension(:), Allocatable, Intent(Out) :: AA
!!$ Integer, Dimension(:), Allocatable, Intent(Out) :: IA,JA
!!$ Integer :: i,j,k
!!$ k=1
!!$ Allocate(AA(nnz),IA(nnz),JA(nnz))
!!$ Do i=1,na
!!$ Do j=1,na
!!$ If (i==j) Then !diagonale principale
!!$ AA(k)=alpha
!!$ IA(k)=i
!!$ JA(k)=j
!!$ k=k+1
!!$ ElseIf ((i==j-1) .and. (modulo(i,nx)/=0)) Then !diagonale sup
!!$ AA(k)=beta
!!$ IA(k)=i
!!$ JA(k)=j
!!$ k=k+1
!!$ ElseIf ((i==j+1) .and. (i/=1) .and. (modulo(j,ny)/=0)) Then !diagonale inf
!!$ AA(k)=beta
!!$ IA(k)=i
!!$ JA(k)=j
!!$ k=k+1
!!$ ElseIf (j==ny+i) Then !diagonale la plus a droite
!!$ AA(k)=gamma
!!$ IA(k)=i
!!$ JA(k)=j
!!$ k=k+1
!!$ ElseIf (i==j+nx) Then !diagonale la plus a gauche
!!$ AA(k)=gamma
!!$ IA(k)=i
!!$ JA(k)=j
!!$ k=k+1
!!$ End If
!!$ End Do
!!$ End Do
!!$End Subroutine matsys
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/DD_Neuman_TRUE_LAST/mod_parametres.f90 | !-----------------------------------------------
! CE MODULE CONTIENT LES PARAMETRES DU PROBLEME
!-----------------------------------------------
Module mod_parametres
USE mpi
Implicit None
!---Précision des calculs -------------------
Integer, Parameter :: PR=8
!--------------------------------------------
!---Parametres géométriques-----------------
Real(PR), Parameter :: Lx=1._PR !Longueur de la barre
Real(PR), Parameter :: Ly=1._PR !Largeur de la barre
Real(PR), Parameter :: D=1._PR !Coefficient de diffusion
!--------------------------------------------
!PARAMETRE DE VISUALISATION:
INTEGER :: sysmove
!---Parametres numériques-------------------
!g means global Domain GLobal matrix WITHOUT DD ADDITIVE
!l means local Domain local matrix
Integer :: nnz_g
Integer, Parameter :: Nx_g=200 !lignes de A (discrétisation en x)
Integer, Parameter :: Ny_g=100 !colonnes de A (discrétisation en y)
Integer, Parameter :: Na_g=Nx_g*Ny_g !taille de la matrice A
Integer, Parameter :: Nt=30 !discrétisation du temps
Real(PR), Parameter :: dx=1._PR/(Real(Nx_g)+1) ! pas en x
Real(PR), Parameter :: dy=1._PR/(Real(Ny_g)+1) ! pas en y
Real(PR), Parameter :: Tf=2._PR !temps final de la simulation
Real(PR), Parameter :: dt=Tf/(Real(Nt)+1) !pas de temps
Real(PR), Parameter :: pi=4._PR*atan(1._PR)
Real(PR), Parameter :: alpha =1._PR+(2._PR*D*dt/(dx**2._PR))+(2._PR*D*dt/(dy**2._PR)) !
Real(PR), Parameter :: beta = (-D*dt)/(dx**2._PR) !AL ! CF coefficients matrice
Real(PR), Parameter :: gamma =(-D*dt)/(dy**2._PR) !AP ! 2 autres coef sont dans
! mod_constr_mat.f90
!-------------------------------------------
!---PARAMETRES MPI--------------------------
INTEGER ::rang,Pivot
INTEGER ::Np
INTEGER ::stateinfo
INTEGER,DIMENSION(MPI_STATUS_SIZE)::status
CHARACTER(LEN=3) ::rank
INTEGER ::TAG !FOR TAG FILE
!------------------------------------------
!---DEFINE INTERVALLE SUIVANT Y PAR PROCS------
INTEGER ::S1_old, S2_old, it1_old, itN_old !avant call charge_overlap
INTEGER ::S1
INTEGER ::S2 !=> X_i^(rang) \in [|S1;S2|]
INTEGER ::it1
INTEGER ::itN !=> P(OMEGA^(rang)) \in [|it1;itN|]
INTEGER ::overlapd
INTEGER ::overlapg
INTEGER,PARAMETER::overlap=1
INTEGER ::Na_l !NBR rows or cols in local matrix
!na_loc == (S2-S1+1)*Ny
INTEGER ::Nx_l !Nx local will be set to S2-S1+1
INTEGER ::Ny_l
INTEGER ::nnz_l !nbr de non zero in local matrix
INTEGER ::crtl_nnz_l !control de nnz
!since a A_l matrix local is made by block D AND C such:
![D][C][0][0] ! |s x 0 0| ! |v 0 0 0| ! A_l.rows=Nx_l*Ny_l=A_l.cols
![C][D][C][0] ![D]=|x s x 0| ![C]=|0 v 0 0| ! D.rows=D.cols=Ny_l
![0][C][D][C] ! |0 x s x| ! |0 0 v 0| ! C.cols=C.rows=Ny_l
![0][0][C][D] ! |0 0 x s| ! |0 0 0 v| !We got (Nx_l) [D] block & (Nx_l-1) [C] upper block
!& (Nx_l-1) [C] lower block
!SUCH THAT crtl_nnz_l=(Nx_l*Ny_l) + 2 * (Nx_l) * (Ny_l - 1) + 2 * (Nx_l - 1) * (Ny_l)
INTEGER ::D_rows !will be set to Ny_l
INTEGER ::D_nnz !will be set to D_rows+2*(D_rows-1)
INTEGER ::C_rows !will be set to Ny_l
INTEGER ::C_nnz !will be set to C_rows
! WE DEFINE a control nnz_l parameter over L1, L2, L3 such that:
!|[D][C][0][0]| = [L1] !avec s=alpha_newmann
INTEGER ::crtl_L1_nnz !will be set to D_nnz+C_nnz
!|[C][D][C][0]| = [L2] !avec s=alpha
!|[0][C][D][C]|
INTEGER ::crtl_L2_nnz !will be set to (Nx_l-2)*(D_nnz+2*C_nnz)
!|[0][0][C][D]| = [L3] !avec s=alpha_newmann
INTEGER ::crtl_L3_nnz !will be set to D_nnz+C_nnz
!SUCH THAT THE RELATION (*) NEED TO BE .TRUE.:
!(*)crtl_L1_nnz+crtl_L2_nnz+crtl_L3_nnz = crtl_nnz_l = nnz_l
INTEGER ::sum_crtl_L_nnz !sum of crtl_Li_nnz
!DANS LE CAS OU Nx_l == 1:
INTEGER :: crtl_L1_nnz_Nxl_EQV_1 ! will be set to D_nnz
!---variables---------------------------------!
Real(PR), Dimension(:), Allocatable :: X
Real(PR), Dimension(:), Allocatable :: Y !Ny_g+2
Real(PR), Dimension(:), Allocatable :: T !Nt+2
Real(PR), Dimension(:), Allocatable :: AA
Integer, Dimension(:), Allocatable :: IA,JA
Real(PR), Dimension(:), Allocatable :: U,Uo,F !Na_l
Real(Pr), Dimension(:), Allocatable :: UG, UD ! CL FROM BORDER IMMERGEE need to be set at zero
Real(PR) :: res,t1,t2 !résidu du grandconj
Integer :: k,i,j,it,CT
!--- VARIABLES DE REDUCTION POUR SIZE OF x, UD, UG
!initialisées in mod_fonctions.f90
INTEGER :: LBX
INTEGER :: UBX !it's set to lbound(x) and ubound(x)
INTEGER :: LBUD, LBUG !it's compute to set lbound(UD) and lbound(UG)
INTEGER :: UBUD, UBUG !it's compute to set ubound(UD) and ubound(UG)
!WILL BE SET TO:
! LBUD = itN+1-2*Ny_g || UBUD = itN
! LBUG = it1 || UBUG = it1-1+2*Ny_g
!NEXT VARIABLES WILL BE USED ITO mod_comm.f90
!FOR SIZE OF VECTORS SEND
INTEGER :: A, B
INTEGER :: C, DD
!A = (itN - 2*overlap*Ny_g) +1; B = A + 2*Ny_g -1
!C = DD - 2*Ny_g +1; DD = (it1 + 2*overlap*Ny_g) -1
!VARIABLES POUR LA BOUCLE SCHWARZ, CONVERGENCE DD:
REAL(PR) :: Norm1, Norm2, C1, err
REAL(PR), PARAMETER :: err_LIM = 0.0000000001_PR!0.0000001_PR
INTEGER :: step
End Module mod_parametres
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/DD_Neuman_TRUE_LAST/mod_sol.f90 | module mod_sol
use mpi
use mod_parametres
IMPLICIT NONE
!*** MODULE ModSOL POUR DONNER LA SOLUTION EXACTE ET
!*** POUR GERER L'ENREGISTREMENT DE LA SOLUTION DANS DES FICHIERS
!*** SUBROUTINE POUR APPELLER UN SCRIPT GNUPLOT POUR LA VISUALISATION
CONTAINS
SUBROUTINE UEXACT(U,userchoice)!userchoice==CT
INTEGER,INTENT(INOUT)::userchoice
REAL(PR),DIMENSION(it1:itN),INTENT(IN)::U
REAL(PR),DIMENSION(:),ALLOCATABLE::UEXA,DIFF
REAL(PR)::ErrN2_RED,ErrN2,Ninf_RED,Ninf
CHARACTER(len=3)::CAS!rank,CAS
!INITIALISATION DE UEXA SUIVANT LE CAS SOURCE
ALLOCATE(UEXA(it1:itN))
WRITE(CAS,fmt='(1I3)')userchoice
OPEN(TAG,file='EXACTE_ERREUR/SOL_EXACTE_CAS'//trim(adjustl(CAS))//'_ME'//trim(adjustl(rank))//'.dat')
SELECT CASE(userchoice)
CASE(1)!F1
DO i=S1,S2
DO j=1,Ny_g
k=j+(i-1)*Ny_g
UEXA(k)=X(i)*(1-X(i))*Y(j)*(1-Y(j))
WRITE(TAG,*)X(i),Y(j),UEXA(k)
END DO
END DO
CASE(2)!F2
DO i=S1,S2
DO j=1,Ny_g
k=j+(i-1)*Ny_g
UEXA(k)=sin(X(i))+cos(Y(j))
WRITE(TAG,*)X(i),Y(j),UEXA(k)
END DO
END DO
CASE DEFAULT!F3 PAS DE SOL EXACTE
PRINT*,'PAS DE SOLUTION EXACTE POUR CE CAS (F3)'
END SELECT
CLOSE(TAG)
!SUR LE DOMAINE [|S1;S2|]x[|1;Ny_g|]:
!ERREUR NORME_2:
ALLOCATE(DIFF(it1:itN))
DIFF=UEXA-U(it1:itN)
ErrN2_RED=DOT_PRODUCT(DIFF,DIFF)
CALL MPI_ALLREDUCE(ErrN2_RED,ErrN2,1,MPI_DOUBLE_PRECISION,MPI_SUM,MPI_COMM_WORLD,stateinfo)
ErrN2=SQRT(ErrN2)
!ERREUR NORME INFINIE
Ninf_RED=MAXVAL(ABS(UEXA(it1:itN)-U(it1:itN)))
CALL MPI_ALLREDUCE(Ninf_RED,Ninf,1,MPI_DOUBLE_PRECISION,MPI_MAX,MPI_COMM_WORLD,stateinfo)
PRINT*,'PAR DOMAINE: ','ERREUR NORME 2 :=',ErrN2,' ERREUR NORME INFINIE :=',Ninf
OPEN(TAG,file='EXACTE_ERREUR/ErrABSOLUE_PAR_DOMAINE'//trim(adjustl(CAS))//'_ME'//trim(adjustl(rank))//'.dat')
DO i=S1,S2
DO j=1,Ny_g!GAP(i,1),GAP(i,2)
k=j+(i-1)*Ny_g!Ny_g
WRITE(TAG,*)X(i),Y(j),-DIFF(k)
END DO
END DO
CLOSE(TAG)
!SUR LE DOMAINE [|S1_old;S2_old|]x[|1;Ny_g|]:
ErrN2_RED=0.0_PR; ErrN2=0.0_PR; Ninf_RED=0.0_PR; Ninf=0.0_PR
!DIFF(it1_old:itN_old)=UEXA(it1_old:itN_old)-U(it1_old:itN_old)
ErrN2_RED=DOT_PRODUCT(DIFF(it1_old:itN_old),DIFF(it1_old:itN_old))
CALL MPI_ALLREDUCE(ErrN2_RED,ErrN2,1,MPI_DOUBLE_PRECISION,MPI_SUM,MPI_COMM_WORLD,stateinfo)
ErrN2=SQRT(ErrN2)
Ninf_RED=MAXVAL(ABS(UEXA(it1_old:itN_old)-U(it1_old:itN_old)))
CALL MPI_ALLREDUCE(Ninf_RED,Ninf,1,MPI_DOUBLE_PRECISION,MPI_MAX,MPI_COMM_WORLD,stateinfo)
PRINT*,'SUR [|S1old;S2old|]: ','ERREUR NORME 2 :=',ErrN2,' ERREUR NORME INFINIE :=',Ninf
OPEN(TAG,file='EXACTE_ERREUR/ErrABSOLUE_oldDD'//trim(adjustl(CAS))//'_ME'//trim(adjustl(rank))//'.dat')
DO i=S1_old,S2_old
DO j=1,Ny_g!GAP(i,1),GAP(i,2)
k=j+(i-1)*Ny_g!Ny_g
WRITE(TAG,*)X(i),Y(j),-DIFF(k)
END DO
END DO
CLOSE(TAG)
DEALLOCATE(DIFF,UEXA)
END SUBROUTINE UEXACT
SUBROUTINE WR_U(U,IT_TEMPS)
INTEGER,INTENT(IN)::IT_TEMPS
REAL(PR),DIMENSION(it1_old:itN_old),INTENT(INOUT)::U
CHARACTER(len=3)::CAS
CHARACTER(len=3)::Ntps
INTEGER::i,j
WRITE(CAS,fmt='(1I3)')CT;WRITE(Ntps,fmt='(1I3)')IT_TEMPS
OPEN(10+rang,file='SOL_NUMERIQUE/U_ME'//trim(adjustl(rank))&
//'_T'//trim(adjustl(Ntps)))
SELECT CASE(CT)
CASE(1)
DO i=S1_old,S2_old
DO j=1,Ny_g
k=j+(i-1)*Ny_g
IF(i-1==0)THEN
WRITE(10+rang,*)0.0_PR,Y(j),0.0_PR
END IF
IF(i+1==Nx_g+1)THEN
WRITE(10+rang,*)Lx,Y(j),0.0_PR
END IF
IF(j-1==0)THEN
WRITE(10+rang,*)X(i),0.0_PR,0.0_PR
END IF
IF(j+1==Ny_g+1)THEN
WRITE(10+rang,*)X(i),Ly,0.0_PR
END IF
WRITE(10+rang,*)X(i),Y(j),U(k)
END DO
END DO
CASE(2)
DO i=S1_old,S2_old
DO j=1,Ny_g
k=j+(i-1)*Ny_g
IF(i==1)THEN!BC OUEST (H)
WRITE(10+rang,*)0.0_PR,Y(j),cos(Y(j))
END IF
IF(i==Nx_g)THEN!BC EST (H)
WRITE(10+rang,*)Lx,Y(j),cos(Y(j))+sin(Lx)
END IF
IF(j==1)THEN!BC SUD (G)
WRITE(10+rang,*)X(i),0.0_PR,1.0_PR+sin(X(i))
END IF
IF(j==Ny_g)THEN!BC NORD (G)
WRITE(10+rang,*)X(i),Ly,cos(Ly)+sin(X(i))
END IF
WRITE(10+rang,*)X(i),Y(j),U(k)
END DO
END DO
CASE(3)
DO i=S1_old,S2_old
DO j=1,Ny_g
k=j+(i-1)*Ny_g
IF(i-1==0)THEN!BC OUEST OU EST (H)
WRITE(10+rang,*)0.0_PR,Y(j),1.0_PR
END IF
IF(i+1==Nx_g+1)THEN!BC OUEST OU EST (H)
WRITE(10+rang,*)Lx,Y(j),1.0_PR
END IF
IF(j-1==0)THEN!BC SUD OU NORD (G)
WRITE(10+rang,*)X(i),0.0_PR,0.0_PR
END IF
IF(j+1==Ny_g+1)THEN!BC SUD OU NORD (G)
WRITE(10+rang,*)X(i),Ly,0.0_PR
END IF
WRITE(10+rang,*)X(i),Y(j),U(k)
END DO
END DO
END SELECT
CLOSE(10+rang)
END SUBROUTINE WR_U
SUBROUTINE VIZU_SOL_NUM(userchoice)!sequentiel call by proc 0 at the end
INTEGER,INTENT(INOUT)::userchoice
CHARACTER(LEN=12)::VIZU
INTEGER::vi1,vi2
VIZU='VIZU_PLT.plt'
PRINT*,'*****************************************************************************************'
PRINT*,'************** VISUALISATION SOLUTION POUR LE CAS #',userchoice,' ***********************'
PRINT*,'*****************************************************************************************'
PRINT*,'************* SACHANT QUE DT=',dt,'ET ITMAX=',Nt,':'
PRINT*,'*****************************************************************************************'
PRINT*,'** ENTREZ LE NUMERO DE L''ITERATION A LAQUELLE VOUS VOULEZ COMMENCER LA VISUALISATION **'
READ*,vi1
PRINT*,'*****************************************************************************************'
PRINT*,'*****************************************************************************************'
PRINT*,'*** ENTREZ LE NUMERO DE L''ITERATION A LAQUELLE VOUS VOULEZ STOPPER LA VISUALISATION ***'
READ*,vi2
PRINT*,'*****************************************************************************************'
PRINT*,'*****************************************************************************************'
OPEN(50,file=VIZU)
SELECT CASE(userchoice)
CASE(1)
WRITE(50,*)'set cbrange[0:0.5]'
CASE(2)
WRITE(50,*)'set cbrange[0.8:2]'
CASE(3)
WRITE(50,*)'set cbrange[0:1]'
END SELECT
WRITE(50,*)'set dgrid3d,',Nx_g+2,',',Ny_g+2; WRITE(50,*)'set hidden3d'; WRITE(50,*)'set pm3d'
!WRITE(50,*)'do for [i=',vi1,':',vi2,']{splot ''SOL_NUMERIQUE/U.dat'' index i u 1:2:3 with pm3d at sb}'
WRITE(50,*)'splot ''SOL_NUMERIQUE/U.dat''u 1:2:3 with pm3d at sb'
CLOSE(50)
call system('gnuplot -p VIZU_PLT.plt')
END SUBROUTINE VIZU_SOL_NUM
SUBROUTINE VIZU_SOL_NUM_ONLY_Nt(userchoice,MINU,MAXU)!sequentiel call by proc 0 at the end
INTEGER,INTENT(INOUT) :: userchoice
REAL(PR),INTENT(IN) :: MINU, MAXU
CHARACTER(LEN=12)::VIZU
VIZU='VIZU_PLT.plt'
PRINT*,'*****************************************************************************************'
PRINT*,'************** VISUALISATION SOLUTION POUR LE CAS #',userchoice,' ***********************'
PRINT*,'*****************************************************************************************'
PRINT*,'************* SACHANT QUE DT=',dt,'ET ITMAX=',Nt,':'
PRINT*,'*****************************************************************************************'
PRINT*,'** VISUALISATION AU TEMPS FINAL **'
PRINT*, (Nt)*dt,' secondes'
PRINT*,'*****************************************************************************************'
OPEN(50,file=VIZU)
SELECT CASE(userchoice)
CASE(1)
WRITE(50,*)'set cbrange[',MINU,':',MAXU,']'
CASE(2)
WRITE(50,*)'set cbrange[',MINU,':',MAXU,']'
CASE(3)
WRITE(50,*)'set cbrange[',MINU,':',MAXU,']'
END SELECT
WRITE(50,*)'set dgrid3d,',Nx_g+2,',',Ny_g+2; WRITE(50,*)'set hidden3d'; WRITE(50,*)'set pm3d'
WRITE(50,*)'splot ''SOL_NUMERIQUE/U.dat'' u 1:2:3 with pm3d at sb'
CLOSE(50)
call system('gnuplot -p VIZU_PLT.plt')
END SUBROUTINE VIZU_SOL_NUM_ONLY_Nt
end module mod_sol
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/MPI_EQ_CHALEUR/ModData.f90 | module ModData
implicit none
!Nx-2 noeuds interieurs suivant x
!Ny-2 noeuds interieurs suivant y
INTEGER,parameter::RK_DATA=8
!ModDATA CONTIENT LA SUBROUTINE POUR LIRE LE FICHIER DATA REMPLIT PAR L'UTILISATEUR
contains
subroutine INI_PARA(rang,Lx,Ly,D,Nx,Ny,PARAMETRES_USER,sysmove,userchoice,DT,ITER_TMAX)
integer,intent(in)::rang
!Lx, Ly longueur suivant x et y
!D coeff de diffusion
!Nx Ny nombre de noeuds dans la direction x et y
!ch nom du fichier à lire pour obtenir les para
real(RK_DATA),intent(out)::Lx,Ly,D,DT
integer,intent(out)::Nx,Ny,sysmove,userchoice,ITER_TMAX
character(len=4),intent(in)::PARAMETRES_USER
open(10+rang,file=PARAMETRES_USER)
read(10+rang,*)
read(10+rang,*)Lx,Ly,D,Nx,Ny!LX,Ly,Nx,Ny:PARAMETRES GEOMETRIQUES ET D: COEFF DIFFUSION
read(10+rang,*)
read(10+rang,*)sysmove!=1 => VISUALISATION SOLUTION; =0 => PAS DE VISUALISATION, JUSTE ECRITURE SOLUTION
read(10+rang,*)
read(10+rang,*)
read(10+rang,*)
read(10+rang,*)
read(10+rang,*)
read(10+rang,*)userchoice!LE CAS SOURCE:1=F1;2=F2;3=F3
read(10+rang,*)
read(10+rang,*)DT,ITER_TMAX!LE PAS DE TEMPS ET L'ITERATION MAX EN TEMPS
close(10+rang)
end subroutine INI_PARA
end module ModData
|
0 | ALLM/ADDITIVE_SCHWARZ_METHOD | ALLM/ADDITIVE_SCHWARZ_METHOD/MPI_EQ_CHALEUR/ModF.f90 | module ModF
use mpi
implicit none
INTEGER,parameter::RK_F=8
! ModF CONTIENT:
!SUBROUTINES PERMETTANT DE CALCULER LES FONCTIONS SOURCES,
!LES FONCTIONS DE BORDS
contains
SUBROUTINE F1(it1,itN,S1,S2,INTER_Y,GAP,X,Y,F)
INTEGER,INTENT(IN)::it1,itN,S1,S2,INTER_Y
INTEGER,DIMENSION(S1:S2,1:2),INTENT(IN)::GAP
REAL(RK_F),DIMENSION(S1:S2),INTENT(IN)::X
REAL(RK_F),DIMENSION(1:INTER_Y),INTENT(IN)::Y
REAL(RK_F),DIMENSION(it1:itN),INTENT(OUT)::F
INTEGER::i,j,k
REAL(RK_F)::FX
DO i=S1,S2!CHARGE LOCALE EN X
FX=X(i)-X(i)**2!POUR i FIXER, ON PEUT NE CALCULER FX QU'UNE SEULE FOIS
DO j=GAP(i,1),GAP(i,2)!CHARGE LOCALE EN Y
k=j+(i-1)*INTER_Y!CHARGE GLOBALE
F(k)=2*(Y(j)-Y(j)**2)+2*FX!CALCUL FONCTION SOURCE
END DO
END DO
END SUBROUTINE F1
SUBROUTINE F2(it1,itN,S1,S2,INTER_Y,GAP,X,Y,F)
INTEGER,INTENT(IN)::it1,itN,S1,S2,INTER_Y
INTEGER,DIMENSION(S1:S2,1:2),INTENT(IN)::GAP
REAL(RK_F),DIMENSION(S1:S2),INTENT(IN)::X
REAL(RK_F),DIMENSION(1:INTER_Y),INTENT(IN)::Y
REAL(RK_F),DIMENSION(it1:itN),INTENT(OUT)::F
INTEGER::i,j,k
REAL(RK_F)::FX
DO i=S1,S2
FX=sin(X(i))!POUR i FIXER, ON PEUT NE CALCULER FX QU'UNE SEULE FOIS
DO j=GAP(i,1),GAP(i,2)
k=j+(i-1)*INTER_Y
F(k)=cos(Y(j))+FX
END DO
END DO
END SUBROUTINE F2
SUBROUTINE F3_FIXE(Lx,Ly,it1,itN,S1,S2,INTER_Y,GAP,X,Y,F)!ON NE STOCKE DANS LE VECTEUR F,
!QUE LA PARTIE FIXE DE F3
REAL(RK_F),INTENT(IN)::Lx,Ly
INTEGER,INTENT(IN)::it1,itN,S1,S2,INTER_Y
INTEGER,DIMENSION(S1:S2,1:2),INTENT(IN)::GAP
REAL(RK_F),DIMENSION(S1:S2),INTENT(IN)::X
REAL(RK_F),DIMENSION(1:INTER_Y),INTENT(IN)::Y
REAL(RK_F),DIMENSION(it1:itN),INTENT(OUT)::F
INTEGER::i,j,k
REAL(RK_F)::FX
DO i=S1,S2
FX=exp(-(X(i)-0.50d0*Lx)**2)!POUR i FIXER, ON PEUT NE CALCULER FX QU'UNE SEULE FOIS
DO j=GAP(i,1),GAP(i,2)
k=j+(i-1)*INTER_Y
F(k)=FX*exp(-(Y(j)-0.50d0*Ly)**2)
END DO
END DO
END SUBROUTINE F3_FIXE
SUBROUTINE WR_F(rang,it1,itN,INTER_Y,F,S1,S2,GAP,X,Y)! ECRITUE DE F DANS LE REPERTOIRE: F
INTEGER,INTENT(IN)::rang,it1,itN,S1,S2,INTER_Y
INTEGER,DIMENSION(S1:S2,1:2),INTENT(IN)::GAP
REAL(RK_F),DIMENSION(S1:S2),INTENT(IN)::X
REAL(RK_F),DIMENSION(1:INTER_Y),INTENT(IN)::Y
REAL(RK_F),DIMENSION(it1:itN),INTENT(IN)::F
INTEGER::i,j,k
CHARACTER(LEN=3)::rank
WRITE(rank,fmt='(1I3)')rang
OPEN(rang+10,file='F/F_'//trim(adjustl(rank))//'.dat')
DO i=S1,S2
DO j=GAP(i,1),GAP(i,2)
k=j+(i-1)*INTER_Y
WRITE(10+rang,*)X(i),Y(j),F(k)
END DO
END DO
CLOSE(10+rang)
END SUBROUTINE WR_F
SUBROUTINE BC(AP,AL,userchoice,S1,S2,GAP,it1,itN,INTER_Y,INTER_X&
,X,Y,DX,DY,Lx,Ly,VECT)!ON CALCUL LES CONDITIONS LIMITES(BC)
REAL(RK_F),INTENT(IN)::AP,AL!LES COEFF DE LA MATRICE
INTEGER,INTENT(IN)::userchoice,S1,S2,it1,itN,INTER_X,INTER_Y
INTEGER,DIMENSION(S1:S2,1:2),INTENT(IN)::GAP
REAL(RK_F),INTENT(IN)::DX,DY,Lx,Ly
REAL(RK_F),DIMENSION(S1:S2),INTENT(IN)::X
REAL(RK_F),DIMENSION(1:INTER_Y),INTENT(IN)::Y
REAL(RK_F),DIMENSION(it1:itN),INTENT(INOUT)::VECT
integer::i,j,k
real(RK_F)::G,H
SELECT CASE(userchoice)
CASE(2)!F2
DO i=S1,S2
DO j=GAP(i,1),GAP(i,2)
k=j+(i-1)*INTER_Y
IF(i==1)THEN!BC H
VECT(k)=VECT(k)+AL*cos(Y(j))
ELSE IF(i==INTER_X)THEN
VECT(k)=VECT(k)+AL*(cos(Y(j))+sin(Lx))
END IF
IF(j==1)THEN!BC G
VECT(k)=VECT(k)+AP*(1.0d0+sin(X(i)))
ELSE IF(j==INTER_Y)THEN
VECT(k)=VECT(k)+AP*(cos(Ly)+sin(X(i)))
END IF
END DO
END DO
CASE(3)!F3
IF(S1==1)THEN!BC
i=S1
DO j=GAP(i,1),GAP(i,2)
k=j+(i-1)*INTER_Y;VECT(k)=VECT(k)+AL !CAR:G=0 ET H=1
END DO
END IF
IF(S2==INTER_X)THEN!BC
i=S2
DO j=GAP(i,1),GAP(i,2)
k=j+(i-1)*INTER_Y;VECT(k)=VECT(k)+AL !CAR:G=0 ET H=1
END DO
END IF
END SELECT
END SUBROUTINE BC
end module ModF
|
End of preview. Expand
in Dataset Viewer.
README.md exists but content is empty.
Use the Edit dataset card button to edit it.
- Downloads last month
- 0