static void RecursiveIntegration(GEdge *ge, IntPoint *from, IntPoint *to,
double (*f) (GEdge *e, double X),
std::vector<IntPoint> &Points,
double Prec, int *depth)
{
IntPoint P, p1;
(*depth)++;
P.t = 0.5 * (from->t + to->t);
P.lc = f(ge, P.t);
double val1 = trapezoidal(from, to);
double val2 = trapezoidal(from, &P);
double val3 = trapezoidal(&P, to);
double err = fabs(val1 - val2 - val3);
if(((err < Prec) && (*depth > 6)) || (*depth > 25)) {
p1 = Points.back();
P.p = p1.p + val2;
Points.push_back(P);
p1 = Points.back();
to->p = p1.p + val3;
Points.push_back(*to);
}
else {
RecursiveIntegration(ge, from, &P, f, Points, Prec, depth);
RecursiveIntegration(ge, &P, to, f, Points, Prec, depth);
}
(*depth)--;
}
void trapezoidalSquareTest() {
double tol = 1e-6;
std::cout << "Trapezoidal Square Test ... ";
unsigned int N = 5000;
bool pass = abs(trapezoidal(sqr, -3.0, 4.0, N) - sqrint(-3.0,4.0)) < tol;
if(pass) std::cout << "PASS" << std::endl;
else {
std::cout << "FAIL" << std::endl;
std::cout << "expected " << sqrint(-3.0,4.0) << ", but was " << trapezoidal(sqr, -3.0, 4.0, N) << std::endl;
}
}
int main(int argc, char ** argv)
{
MPI_Init(&argc, &argv);
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
// Arguments...
const unsigned long int precision = 4e9;
const double a = 0.0;
const double b = 10.0;
double start_time = MPI_Wtime();
// compute integral
double integral = trapezoidal(a,b,precision);
double end_time = MPI_Wtime();
if( rank == 0)
std::cout << size << " " << integral << " " << end_time - start_time << std::endl << std::endl;
MPI_Finalize();
return 1;
}
/* Evaluates the specified membership function in the given 'x' value */
static double
eval_MF (MF_t mf, double x)
{
switch (mf.k) {
case (triang):
return triangular (mf.p[0], mf.p[1], mf.p[2], x);
break;
case (trap):
return trapezoidal (mf.p[0], mf.p[1], mf.p[2], mf.p[3], x);
break;
case (gauss):
return gaussian (mf.p[0], mf.p[1], x);
break;
case (bell):
return belly (mf.p[0], mf.p[1], mf.p[2], x);
break;
default:
fprintf (stderr, "anfis.c: eval_MF: ERROR: unknown MF\n");
return 0.0;
break;
}
}
int main(int argc,char *argv[]) {
double xstart,xstop,xinc;
if (argc != 6) {
fprintf(stderr,"%s <e> <Semi-Major axis> <xstart> <xstop> <xinc>\n",argv[0]);
exit(1);
}
e = atof(argv[1]);
a = atof(argv[2]);
xstart = atof(argv[3]);
xstop = atof(argv[4]);
xinc = atof(argv[5]);
printf("Trapezoidal rule:\n");
trapezoidal(function,xstart,xstop,xinc);
printf("Simpson's rule:\n");
simpson(function,xstart,xstop,xinc);
exit(0);
}
int main() {
// Height of the capillary interface for the grid
CpuPtr_2D height_distribution(nx, ny, 0, true);
computeRandomHeights(0, H, height_distribution);
// Density difference between brine and CO2
float delta_rho = 500;
// Gravitational acceleration
float g = 9.87;
// Non-dimensional constant that scales the strength of the capillary forces
float c_cap = 1.0/6.0;
// Permeability data (In real simulations this will be a table based on rock data, here we use a random distribution )
float k_data[10] = {0.9352, 1.0444, 0.9947, 0.9305, 0.9682, 1.0215, 0.9383, 1.0477, 0.9486, 1.0835};
float k_heights[10] = {10, 20, 25, 100, 155, 193, 205, 245, 267, 300};
//Inside Kernel
// Converting the permeability data into a table of even subintervals in the z-directions
//float k_values[n+1];
//kDistribution(dz, h, k_heights, k_data, k_values);
// MOBILITY
// The mobility is a function of the saturation, which is directly related to the capillary pressure
// Pressure at capillary interface, which is known
float p_ci = 1;
// Table of capillary pressure values for our subintervals along the z-axis ranging from 0 to h
float resolution = 0.01;
int size = 1/resolution + 1;
float p_cap_ref_table[size];
float s_b_ref_table[size];
createReferenceTable(g, H, delta_rho, c_cap, resolution, p_cap_ref_table, s_b_ref_table);
// Set block and grid sizes and initialize gpu pointer
dim3 grid;
dim3 block;
computeGridBlock(dim3& grid, dim3& block, nx, ny, block_x, block_y);
// Allocate and set data on the GPU
GpuPtr_2D Lambda_device(nx, ny, 0, NULL);
GpuPtr_1D k_data_device(10, k_data);
GpuPtr_1D k_heights_device(10, k_heights);
GpuPtr_1D p_cap_ref_table_device(size, p_cap_ref_table);
GpuPtr_1D s_b_ref_table_device(size, s_b_ref_table);
cudaHostAlloc(&args, sizeof(CoarsePermIntegrationKernelArgs), cudaHostAllocWriteCombined);
// Set arguments and run coarse integration kernel
CoarsePermIntegrationArgs coarse_perm_int_args;
setCoarsePermIntegrationArgs(coarse_perm_int_args,\
Lambda_device.getRawPtr(),\
k_data_device.getRawPtr(),\
k_heights_device.getRawPtr(),\
p_cap_ref_table_device.getRawPtr(),\
s_b_ref_table_device.getRawPtr(),\
nx, ny, 0);
callCoarseIntegrationKernel(grid, block, coarse_perm_int_args);
float p_cap_values[n+1];
computeCapillaryPressure(p_ci, g, delta_rho, h, dz, n, p_cap_values);
float s_b_values[n+1];
inverseCapillaryPressure(n, g, h, delta_rho, c_cap, p_cap_values, s_b_values);
printArray(n+1, s_b_values);
// End point mobility lambda'_b, a known quantity
float lambda_end_point = 1;
float lambda_values[n+1];
computeMobility(n, s_b_values, lambda_end_point, lambda_values);
// Multiply permeability values with lambda values
float f_values[n+1];
multiply(n+1, lambda_values, k_values, f_values);
//Numerical integral with trapezoidal
float K = trapezoidal(dz, n, k_values);
float L = trapezoidal(dz, n, f_values)/K;
printf("Value of integral K. %.4f", K);
printf("Value of integral L. %.4f", L);
}
