TEST(algorithm_test, should_calculate_std_dev)
{
EQUAL(2, std_dev(std::begin(data_a), std::end(data_a)));
EQUAL(4, std_dev(data_b.begin(), data_b.end()));
EQUAL(222.2, std_dev(data_c.begin(), data_c.end()));
EQUAL(2, std_dev(data_d.begin(), data_d.end()));
}
int main() {
int cycles = 1000;
uint64_t start;
uint64_t end;
uint64_t data[cycles];
for (int i = 0; i < cycles; i++) {
start = mach_absolute_time();
//int pid = fork();
int pid = vfork();
end = mach_absolute_time();
if (start > end) {
fprintf(stderr, "WRONG\n");
exit(1);
}
if (pid == 0) {
exit(0);
} else {
data[i] = (end - start);
int ptr;
}
}
double std_dev_val = std_dev(data, cycles);
double mean_val = mean(data, cycles);
printf("\nMean: %f\nStand: %f\n", mean_val, std_dev_val);
return 0;
}
int main(int argc, char ** argv) {
if (argc < 2) {
fprintf(stderr, "Wrong num args\n");
exit(0);
}
int data_points = 1000000;
uint64_t size = (uint64_t) pow(2, atoi(argv[1]));
uint64_t step = (uint64_t) (atoi(argv[2]));
uint64_t start;
uint64_t end;
uint64_t * list = make_list(size, step);
uint64_t * ptr = list;
int index = 0;
uint64_t data[data_points];
memset(data, 0, data_points);
while (index < data_points) {
uint64_t * old_ptr = ptr;
start = mach_absolute_time();
ptr = *ptr;
end = mach_absolute_time();
data[index] = (end - start);
index++;
}
free(list);
double std_dev_val = std_dev(data, data_points);
double mean_val = mean(data, data_points);
fprintf(stderr, "%f\n", mean_val);
printf("%llu\t%llu\t%f\n", step, (uint64_t) atoi(argv[1]), mean_val);
}
main()
{
// make it so.
printf("standard deviation is = %f",
std_dev(x,ary_len(x))
);
}
const double rms_energy_spread(ParticleState const &ps, double vacuum_c)
{
if (ps.particle_count == 0)
return 0;
py_vector energies = kinetic_energies(ps, vacuum_c);
return std_dev(energies.begin(), energies.end());
}
void fit_plot(double upres,double lowres,double upcen,double lowcen){
double p0[4],p[4],half,width,max;
int i,j,k,ud,info;
char str1[256];
FitGraceinit();
half=0.0;
GracePrintf("focus g0");
for(i=0;i<NCH;i++) dis[i]=0;
for(j=0;j<4;j++)
{
for(k=0;k<NCH;k++)
{
max=fits[j][k][3]+2.0*fits[j][k][0];
if ((fits[j][k][1]>=lowcen)&&(fits[j][k][1]<=upcen)&&(fits[j][k][2]>=lowres)&&(fits[j][k][2]<=upres))
{
printf("In: k=%i Center=%lg width=%lg min=%lg max=%lg\n",k,fits[j][k][1],fits[j][k][2],max);
sprintf(str1,"g0.s0 point %lg, %lg",fits[j][k][1],fits[j][k][2]);
GracePrintf(str1);
}
else
{
dis[k]=1;
printf("Out:k=%i Center=%lg width=%lg max=%lg min=%lg\n",k,fits[j][k][1],fits[j][k][2],max);
sprintf(str1,"g0.s1 point %lg, %lg",fits[j][k][1],fits[j][k][2]);
GracePrintf(str1);
}
} // for k
GracePrintf("autoscale");
GracePrintf("redraw");
} // for j
printf("%lg %lg %lg %lg\n",upcen, lowcen,upres,lowres);
std_dev();
}
void Statistics::updateFinalAverages(){
//cpuUtilizations
mean(cpuUtilizations, averageCpuUtilization);
std_dev(cpuUtilizations, stdDevCpuUtilization);
auto rTmin = std::min_element(cpuUtilizations.begin(), cpuUtilizations.end());
auto place = std::distance(cpuUtilizations.begin(), rTmin);
if(place >=0)
minCpuUtilization = cpuUtilizations.at(place);
auto rTmax = std::max_element(cpuUtilizations.begin(), cpuUtilizations.end());
place = std::distance(cpuUtilizations.begin(), rTmax);
if(place >=0)
maxCpuUtilization = cpuUtilizations.at(place);
//Throughputs
mean(throughputs, averageThroughput);
std_dev(throughputs, stdDevThroughput);
rTmin = std::min_element(throughputs.begin(), throughputs.end());
place = std::distance(throughputs.begin(), rTmin);
if(place >=0)
minThroughput = throughputs.at(place);
rTmax = std::max_element(throughputs.begin(), throughputs.end());
place = std::distance(throughputs.begin(), rTmax);
if(place >=0)
maxThroughput = throughputs.at(place);
for(int i =0; i < ioUtilizations.size(); ++i){
//IO Updates
mean(ioUtilizations.at(i), averageIoUtilization.at(i));
std_dev(ioUtilizations.at(i), stdDevIoUtilization.at(i));
rTmin = std::min_element(ioUtilizations.at(i).begin(), ioUtilizations.at(i).end());
place = std::distance(ioUtilizations.at(i).begin(), rTmin);
if(place >=0)
minIoUtilization.at(i)= ioUtilizations.at(i).at(place);
rTmax = std::max_element(ioUtilizations.at(i).begin(), ioUtilizations.at(i).end());
place = std::distance(ioUtilizations.at(i).begin(), rTmax);
if(place >=0)
maxIoUtilization.at(i) = ioUtilizations.at(i).at(place);
}
}
double sd_norm_res(const dvar_vector& pred, const dvector& obs, double m)
{
RETURN_ARRAYS_INCREMENT();
double sdnr;
dvector pp = value(pred)+ 0.0001;
sdnr = std_dev(norm_res(pp,obs,m));
RETURN_ARRAYS_DECREMENT();
return sdnr;
}
void Statistics::updateAverages(){
if(System::instance()->getMaxCpuSize() > maxCpuRSSize)
maxCpuRSSize = System::instance()->getMaxCpuSize();
//response times
mean(responseTimes, averageResponseTime);
std_dev(responseTimes, stdDevResponseTime);
auto rTmin = std::min_element(responseTimes.begin(), responseTimes.end());
auto place = std::distance(responseTimes.begin(), rTmin);
if(place >=0)
minResponseTime = responseTimes.at(place);
auto rTmax = std::max_element(responseTimes.begin(), responseTimes.end());
place = std::distance(responseTimes.begin(), rTmax);
if(place >=0)
maxResponseTime = responseTimes.at(place);
//latencies
mean(latencies, averageLatency);
std_dev(latencies, stdDevLatency);
rTmin = std::min_element(latencies.begin(), latencies.end());
place = std::distance(latencies.begin(), rTmin);
if(place >=0)
minLatency = latencies.at(place);
rTmax = std::max_element(latencies.begin(), latencies.end());
place = std::distance(latencies.begin(), rTmax);
if(place >=0)
maxLatency = latencies.at(place);
//cpu and IO utilizations
//throughput
if(throughputs.size() < 1){
indivCpuIoAverages();
}
else{
updateFinalAverages();
}
}
/**
* Normalization of the features using the standardization method
*/
vector< VectorXd > FeatureExtractor::normalizeFeatures(vector< VectorXd > featuresSeq){
int T = featuresSeq.size();
int numFeatures = featuresSeq[0].size();
VectorXd mean = VectorXd::Zero(numFeatures);
VectorXd std_dev = VectorXd::Zero(numFeatures);
//1. compute mean
for(int i = 0; i < T; ++i)
mean += featuresSeq[i]; //element-wise operation
for(int i = 0; i < numFeatures; ++i)
{
mean(i) /= T;
}
//2. compute standard deviation
for(int i = 0; i < T; ++i) {
VectorXd diff = featuresSeq[i] - mean;
for(int j = 0; j < numFeatures; ++j)
diff(j) = diff(j) * diff(j);
std_dev += diff;
}
for(int i = 0; i < numFeatures; ++i)
std_dev(i) = sqrt( std_dev(i)/T );
//3. normalize features
for(int i = 0; i < T; ++i) {
for(int j = 0; j < numFeatures; ++j) {
featuresSeq[i](j) = (featuresSeq[i](j) - mean(j));
if(std_dev(j) != 0)
featuresSeq[i](j) /= std_dev(j);
// cout << featuresSeq[i](j) << " ";
}
// cout << "\n";
}
return featuresSeq;
}
int main(void) {
/*simulated stock values*/
double stocks[] = {14850.0,14700.0,14680.0,14720.0,14800.0};
/*variable to hold the standard deviation*/
double stnd_devi = 0.0;
int i;
printf("Values: \n");
for(i = 0; i < 5; i++){
/*Print each element of the array*/
printf("%f \n", stocks[i]);
}
/*Using the basic library provided, compute the standard deviation*/
stnd_devi = std_dev(stocks, 5);
/*print standard deviation*/
printf("The standard Deviation is: %lf \n", stnd_devi);
return 0;
}
/**
* Calculate the mean and standard deviation of the k-mer frequency
*/
void set_k_freq(bwa_seq_t *read, counter *k_count, uint16_t *kmer_list,
const int k) {
hash_key key = 0;
int i = 0;
double counted_len = read->len - k;
double *base_counter = (double*) calloc(read->len - k + 1, sizeof(double));
for (i = 0; i <= read->len - k; i++) {
key = get_key(read, i, i + k);
k_count->k_freq += kmer_list[key];
}
for (i = 0; i <= read->len - k; i++) {
key = get_key(read, i, i + k);
base_counter[i] = kmer_list[key];
}
k_count->k_mean = mean(base_counter, counted_len);
k_count->k_sd = std_dev(base_counter, counted_len);
free(base_counter);
}
//____________________________________________________________
static int _print_result (FILE* fd, long start, long limit, long *table)
{
long i, d, min=0xffff, max=0, sum=0, total;
float avg;
float ratio = time_ratio();
if (!limit) return 0;
for (i = start; i < limit; i++) {
table[i] = (long)(table[i]*ratio);
d = table[i];
if (d < min) min = d;
else if (d > max) max = d;
sum += d;
fprintf (fd, "%ld\n", d);
}
total = limit - start;
fprintf (fd, "total calls achieved: %ld\n", total);
fprintf (fd, "min time: %ld\n", min);
fprintf (fd, "max time: %ld\n", max);
fprintf (fd, "average : %f\n", avg = (float)sum / total);
fprintf (fd, "std dev : %ld\n", std_dev(start, limit, table, (long)avg));
return 1;
}
// Main
int main(int argc, char ** argv) {
// Choose the best GPU in case there are multiple available
choose_GPU();
// Keep track of the start time of the program
long long program_start_time = get_time();
if (argc !=3){
fprintf(stderr, "usage: %s <input file> <number of frames to process>", argv[0]);
exit(1);
}
// Let the user specify the number of frames to process
int num_frames = atoi(argv[2]);
// Open video file
char *video_file_name = argv[1];
avi_t *cell_file = AVI_open_input_file(video_file_name, 1);
if (cell_file == NULL) {
AVI_print_error("Error with AVI_open_input_file");
return -1;
}
int i, j, *crow, *ccol, pair_counter = 0, x_result_len = 0, Iter = 20, ns = 4, k_count = 0, n;
MAT *cellx, *celly, *A;
double *GICOV_spots, *t, *G, *x_result, *y_result, *V, *QAX_CENTERS, *QAY_CENTERS;
double threshold = 1.8, radius = 10.0, delta = 3.0, dt = 0.01, b = 5.0;
// Extract a cropped version of the first frame from the video file
MAT *image_chopped = get_frame(cell_file, 0, 1, 0);
printf("Detecting cells in frame 0\n");
// Get gradient matrices in x and y directions
MAT *grad_x = gradient_x(image_chopped);
MAT *grad_y = gradient_y(image_chopped);
// Allocate for gicov_mem and strel
gicov_mem = (float*) malloc(sizeof(float) * grad_x->m * grad_y->n);
strel = (float*) malloc(sizeof(float) * strel_m * strel_n);
m_free(image_chopped);
int grad_m = grad_x->m;
int grad_n = grad_y->n;
#pragma acc data create(sin_angle,cos_angle,theta,tX,tY) \
create(gicov_mem[0:grad_x->m*grad_y->n])
{
// Precomputed constants on GPU
compute_constants();
// Get GICOV matrices corresponding to image gradients
long long GICOV_start_time = get_time();
MAT *gicov = GICOV(grad_x, grad_y);
long long GICOV_end_time = get_time();
// Dilate the GICOV matrices
long long dilate_start_time = get_time();
MAT *img_dilated = dilate(gicov);
long long dilate_end_time = get_time();
} /* end acc data */
// Find possible matches for cell centers based on GICOV and record the rows/columns in which they are found
pair_counter = 0;
crow = (int *) malloc(gicov->m * gicov->n * sizeof(int));
ccol = (int *) malloc(gicov->m * gicov->n * sizeof(int));
for(i = 0; i < gicov->m; i++) {
for(j = 0; j < gicov->n; j++) {
if(!double_eq(m_get_val(gicov,i,j), 0.0) && double_eq(m_get_val(img_dilated,i,j), m_get_val(gicov,i,j)))
{
crow[pair_counter]=i;
ccol[pair_counter]=j;
pair_counter++;
}
}
}
GICOV_spots = (double *) malloc(sizeof(double) * pair_counter);
for(i = 0; i < pair_counter; i++)
GICOV_spots[i] = sqrt(m_get_val(gicov, crow[i], ccol[i]));
G = (double *) calloc(pair_counter, sizeof(double));
x_result = (double *) calloc(pair_counter, sizeof(double));
y_result = (double *) calloc(pair_counter, sizeof(double));
x_result_len = 0;
for (i = 0; i < pair_counter; i++) {
if ((crow[i] > 29) && (crow[i] < BOTTOM - TOP + 39)) {
x_result[x_result_len] = ccol[i];
y_result[x_result_len] = crow[i] - 40;
G[x_result_len] = GICOV_spots[i];
x_result_len++;
}
}
// Make an array t which holds each "time step" for the possible cells
t = (double *) malloc(sizeof(double) * 36);
for (i = 0; i < 36; i++) {
t[i] = (double)i * 2.0 * PI / 36.0;
}
// Store cell boundaries (as simple circles) for all cells
cellx = m_get(x_result_len, 36);
celly = m_get(x_result_len, 36);
for(i = 0; i < x_result_len; i++) {
for(j = 0; j < 36; j++) {
m_set_val(cellx, i, j, x_result[i] + radius * cos(t[j]));
m_set_val(celly, i, j, y_result[i] + radius * sin(t[j]));
}
}
A = TMatrix(9,4);
V = (double *) malloc(sizeof(double) * pair_counter);
QAX_CENTERS = (double * )malloc(sizeof(double) * pair_counter);
QAY_CENTERS = (double *) malloc(sizeof(double) * pair_counter);
memset(V, 0, sizeof(double) * pair_counter);
memset(QAX_CENTERS, 0, sizeof(double) * pair_counter);
memset(QAY_CENTERS, 0, sizeof(double) * pair_counter);
// For all possible results, find the ones that are feasibly leukocytes and store their centers
k_count = 0;
for (n = 0; n < x_result_len; n++) {
if ((G[n] < -1 * threshold) || G[n] > threshold) {
MAT * x, *y;
VEC * x_row, * y_row;
x = m_get(1, 36);
y = m_get(1, 36);
x_row = v_get(36);
y_row = v_get(36);
// Get current values of possible cells from cellx/celly matrices
x_row = get_row(cellx, n, x_row);
y_row = get_row(celly, n, y_row);
uniformseg(x_row, y_row, x, y);
// Make sure that the possible leukocytes are not too close to the edge of the frame
if ((m_min(x) > b) && (m_min(y) > b) && (m_max(x) < cell_file->width - b) && (m_max(y) < cell_file->height - b)) {
MAT * Cx, * Cy, *Cy_temp, * Ix1, * Iy1;
VEC *Xs, *Ys, *W, *Nx, *Ny, *X, *Y;
Cx = m_get(1, 36);
Cy = m_get(1, 36);
Cx = mmtr_mlt(A, x, Cx);
Cy = mmtr_mlt(A, y, Cy);
Cy_temp = m_get(Cy->m, Cy->n);
for (i = 0; i < 9; i++)
m_set_val(Cy, i, 0, m_get_val(Cy, i, 0) + 40.0);
// Iteratively refine the snake/spline
for (i = 0; i < Iter; i++) {
int typeofcell;
if(G[n] > 0.0) typeofcell = 0;
else typeofcell = 1;
splineenergyform01(Cx, Cy, grad_x, grad_y, ns, delta, 2.0 * dt, typeofcell);
}
X = getsampling(Cx, ns);
for (i = 0; i < Cy->m; i++)
m_set_val(Cy_temp, i, 0, m_get_val(Cy, i, 0) - 40.0);
Y = getsampling(Cy_temp, ns);
Ix1 = linear_interp2(grad_x, X, Y);
Iy1 = linear_interp2(grad_x, X, Y);
Xs = getfdriv(Cx, ns);
Ys = getfdriv(Cy, ns);
Nx = v_get(Ys->dim);
for (i = 0; i < Ys->dim; i++)
v_set_val(Nx, i, v_get_val(Ys, i) / sqrt(v_get_val(Xs, i)*v_get_val(Xs, i) + v_get_val(Ys, i)*v_get_val(Ys, i)));
Ny = v_get(Xs->dim);
for (i = 0; i < Xs->dim; i++)
v_set_val(Ny, i, -1.0 * v_get_val(Xs, i) / sqrt(v_get_val(Xs, i)*v_get_val(Xs, i) + v_get_val(Ys, i)*v_get_val(Ys, i)));
W = v_get(Nx->dim);
for (i = 0; i < Nx->dim; i++)
v_set_val(W, i, m_get_val(Ix1, 0, i) * v_get_val(Nx, i) + m_get_val(Iy1, 0, i) * v_get_val(Ny, i));
V[n] = mean(W) / std_dev(W);
// Find the cell centers by computing the means of X and Y values for all snaxels of the spline contour
QAX_CENTERS[k_count] = mean(X);
QAY_CENTERS[k_count] = mean(Y) + TOP;
k_count++;
// Free memory
v_free(W);
v_free(Ny);
v_free(Nx);
v_free(Ys);
v_free(Xs);
m_free(Iy1);
m_free(Ix1);
v_free(Y);
v_free(X);
m_free(Cy_temp);
m_free(Cy);
m_free(Cx);
}
// Free memory
v_free(y_row);
v_free(x_row);
m_free(y);
m_free(x);
}
}
// Free memory
free(gicov_mem);
free(strel);
free(V);
free(ccol);
free(crow);
free(GICOV_spots);
free(t);
free(G);
free(x_result);
free(y_result);
m_free(A);
m_free(celly);
m_free(cellx);
m_free(img_dilated);
m_free(gicov);
m_free(grad_y);
m_free(grad_x);
// Report the total number of cells detected
printf("Cells detected: %d\n\n", k_count);
// Report the breakdown of the detection runtime
printf("Detection runtime\n");
printf("-----------------\n");
printf("GICOV computation: %.5f seconds\n", ((float) (GICOV_end_time - GICOV_start_time)) / (1000*1000));
printf(" GICOV dilation: %.5f seconds\n", ((float) (dilate_end_time - dilate_start_time)) / (1000*1000));
printf(" Total: %.5f seconds\n", ((float) (get_time() - program_start_time)) / (1000*1000));
// Now that the cells have been detected in the first frame,
// track the ellipses through subsequent frames
if (num_frames > 1) printf("\nTracking cells across %d frames\n", num_frames);
else printf("\nTracking cells across 1 frame\n");
long long tracking_start_time = get_time();
int num_snaxels = 20;
ellipsetrack(cell_file, QAX_CENTERS, QAY_CENTERS, k_count, radius, num_snaxels, num_frames);
printf(" Total: %.5f seconds\n", ((float) (get_time() - tracking_start_time)) / (float) (1000*1000*num_frames));
// Report total program execution time
printf("\nTotal application run time: %.5f seconds\n", ((float) (get_time() - program_start_time)) / (1000*1000));
return 0;
}
int main(int argc, char *argv[]) {
int n = 32; // spatial discretization (per dimension)
int num_KL = 2; // number of KL terms
int p = 3; // polynomial order
double mu = 0.1; // mean of exponential random field
double s = 0.2; // std. dev. of exponential r.f.
bool nonlinear_expansion = false; // nonlinear expansion of diffusion coeff
// (e.g., log-normal)
bool symmetric = false; // use symmetric formulation
double g_mean_exp = 0.172988; // expected response mean
double g_std_dev_exp = 0.0380007; // expected response std. dev.
double g_tol = 1e-6; // tolerance on determining success
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
int MyPID;
try {
{
TEUCHOS_FUNC_TIME_MONITOR("Total PCE Calculation Time");
// Create a communicator for Epetra objects
Teuchos::RCP<const Epetra_Comm> globalComm;
#ifdef HAVE_MPI
globalComm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
globalComm = Teuchos::rcp(new Epetra_SerialComm);
#endif
MyPID = globalComm->MyPID();
// Create Stochastic Galerkin basis and expansion
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(num_KL);
for (int i=0; i<num_KL; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p,true));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases,
1e-12));
int sz = basis->size();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk;
if (nonlinear_expansion)
Cijk = basis->computeTripleProductTensor(sz);
else
Cijk = basis->computeTripleProductTensor(num_KL+1);
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > expansion =
Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<int,double>(basis,
Cijk));
if (MyPID == 0)
std::cout << "Stochastic Galerkin expansion size = " << sz << std::endl;
// Create stochastic parallel distribution
int num_spatial_procs = -1;
Teuchos::ParameterList parallelParams;
parallelParams.set("Number of Spatial Processors", num_spatial_procs);
// parallelParams.set("Rebalance Stochastic Graph", true);
// Teuchos::ParameterList& isorropia_params =
// parallelParams.sublist("Isorropia");
// isorropia_params.set("Balance objective", "nonzeros");
Teuchos::RCP<Stokhos::ParallelData> sg_parallel_data =
Teuchos::rcp(new Stokhos::ParallelData(basis, Cijk, globalComm,
parallelParams));
Teuchos::RCP<const EpetraExt::MultiComm> sg_comm =
sg_parallel_data->getMultiComm();
Teuchos::RCP<const Epetra_Comm> app_comm =
sg_parallel_data->getSpatialComm();
// Create application
Teuchos::RCP<twoD_diffusion_ME> model =
Teuchos::rcp(new twoD_diffusion_ME(app_comm, n, num_KL, mu, s, basis,
nonlinear_expansion, symmetric));
// Setup stochastic Galerkin algorithmic parameters
Teuchos::RCP<Teuchos::ParameterList> sgParams =
Teuchos::rcp(new Teuchos::ParameterList);
if (!nonlinear_expansion) {
sgParams->set("Parameter Expansion Type", "Linear");
sgParams->set("Jacobian Expansion Type", "Linear");
}
Teuchos::ParameterList precParams;
precParams.set("default values", "SA");
precParams.set("ML output", 0);
precParams.set("max levels",5);
precParams.set("increasing or decreasing","increasing");
precParams.set("aggregation: type", "Uncoupled");
precParams.set("smoother: type","ML symmetric Gauss-Seidel");
precParams.set("smoother: sweeps",2);
precParams.set("smoother: pre or post", "both");
precParams.set("coarse: max size", 200);
//precParams.set("PDE equations",sz);
#ifdef HAVE_ML_AMESOS
precParams.set("coarse: type","Amesos-KLU");
#else
precParams.set("coarse: type","Jacobi");
#endif
// Create stochastic Galerkin model evaluator
Teuchos::RCP<Stokhos::SGModelEvaluator_Interlaced> sg_model =
Teuchos::rcp(new Stokhos::SGModelEvaluator_Interlaced(
model, basis, Teuchos::null,
expansion, sg_parallel_data,
sgParams));
// Set up stochastic parameters
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_p_poly =
sg_model->create_p_sg(0);
for (int i=0; i<num_KL; i++) {
sg_p_poly->term(i,0)[i] = 0.0;
sg_p_poly->term(i,1)[i] = 1.0;
}
// Create vectors and operators
Teuchos::RCP<const Epetra_Vector> sg_p = sg_p_poly->getBlockVector();
Teuchos::RCP<Epetra_Vector> sg_x =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_x_map())));
sg_x->PutScalar(0.0);
Teuchos::RCP<Epetra_Vector> sg_f =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_f_map())));
Teuchos::RCP<Epetra_Vector> sg_dx =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_x_map())));
Teuchos::RCP<Epetra_CrsMatrix> sg_J =
Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(sg_model->create_W());
Teuchos::RCP<ML_Epetra::MultiLevelPreconditioner> sg_M =
Teuchos::rcp(new ML_Epetra::MultiLevelPreconditioner(*sg_J, precParams,
false));
// Setup InArgs and OutArgs
EpetraExt::ModelEvaluator::InArgs sg_inArgs = sg_model->createInArgs();
EpetraExt::ModelEvaluator::OutArgs sg_outArgs = sg_model->createOutArgs();
sg_inArgs.set_p(1, sg_p);
sg_inArgs.set_x(sg_x);
sg_outArgs.set_f(sg_f);
sg_outArgs.set_W(sg_J);
// Evaluate model
sg_model->evalModel(sg_inArgs, sg_outArgs);
sg_M->ComputePreconditioner();
// Print initial residual norm
double norm_f;
sg_f->Norm2(&norm_f);
if (MyPID == 0)
std::cout << "\nInitial residual norm = " << norm_f << std::endl;
// Setup AztecOO solver
AztecOO aztec;
if (symmetric)
aztec.SetAztecOption(AZ_solver, AZ_cg);
else
aztec.SetAztecOption(AZ_solver, AZ_gmres);
aztec.SetAztecOption(AZ_precond, AZ_none);
aztec.SetAztecOption(AZ_kspace, 20);
aztec.SetAztecOption(AZ_conv, AZ_r0);
aztec.SetAztecOption(AZ_output, 1);
aztec.SetUserOperator(sg_J.get());
aztec.SetPrecOperator(sg_M.get());
aztec.SetLHS(sg_dx.get());
aztec.SetRHS(sg_f.get());
// Solve linear system
aztec.Iterate(1000, 1e-12);
// Update x
sg_x->Update(-1.0, *sg_dx, 1.0);
// Save solution to file
EpetraExt::VectorToMatrixMarketFile("stochastic_solution_interlaced.mm",
*sg_x);
// Save RHS to file
EpetraExt::VectorToMatrixMarketFile("stochastic_RHS_interlaced.mm",
*sg_f);
// Save operator to file
EpetraExt::RowMatrixToMatrixMarketFile("stochastic_operator_interlaced.mm",
*sg_J);
// Save mean and variance to file
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_poly =
sg_model->create_x_sg(View, sg_x.get());
Epetra_Vector mean(*(model->get_x_map()));
Epetra_Vector std_dev(*(model->get_x_map()));
sg_x_poly->computeMean(mean);
sg_x_poly->computeStandardDeviation(std_dev);
EpetraExt::VectorToMatrixMarketFile("mean_gal_interlaced.mm", mean);
EpetraExt::VectorToMatrixMarketFile("std_dev_gal_interlaced.mm", std_dev);
// Compute new residual & response function
EpetraExt::ModelEvaluator::OutArgs sg_outArgs2 = sg_model->createOutArgs();
Teuchos::RCP<Epetra_Vector> sg_g =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_g_map(0))));
sg_f->PutScalar(0.0);
sg_outArgs2.set_f(sg_f);
sg_outArgs2.set_g(0, sg_g);
sg_model->evalModel(sg_inArgs, sg_outArgs2);
// Print initial residual norm
sg_f->Norm2(&norm_f);
if (MyPID == 0)
std::cout << "\nFinal residual norm = " << norm_f << std::endl;
// Print mean and standard deviation of responses
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_g_poly =
sg_model->create_g_sg(0, View, sg_g.get());
Epetra_Vector g_mean(*(model->get_g_map(0)));
Epetra_Vector g_std_dev(*(model->get_g_map(0)));
sg_g_poly->computeMean(g_mean);
sg_g_poly->computeStandardDeviation(g_std_dev);
std::cout.precision(16);
// std::cout << "\nResponse Expansion = " << std::endl;
// std::cout.precision(12);
// sg_g_poly->print(std::cout);
std::cout << "\nResponse Mean = " << std::endl << g_mean << std::endl;
std::cout << "Response Std. Dev. = " << std::endl << g_std_dev << std::endl;
// Determine if example passed
bool passed = false;
if (norm_f < 1.0e-10 &&
std::abs(g_mean[0]-g_mean_exp) < g_tol &&
std::abs(g_std_dev[0]-g_std_dev_exp) < g_tol)
passed = true;
if (MyPID == 0) {
if (passed)
std::cout << "Example Passed!" << std::endl;
else
std::cout << "Example Failed!" << std::endl;
}
}
Teuchos::TimeMonitor::summarize(std::cout);
Teuchos::TimeMonitor::zeroOutTimers();
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (string& s) {
std::cout << s << std::endl;
}
catch (char *s) {
std::cout << s << std::endl;
}
catch (...) {
std::cout << "Caught unknown exception!" <<std:: endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
}
int main(int argc, char **argv)
{
try {
const int d = 5;
const int pmin = 1;
const int pmax = 10;
const int np = pmax-pmin+1;
const double a = 1.5;
bool use_pce_quad_points = false;
bool normalize = false;
bool project_integrals = false;
bool lanczos = true;
bool sparse_grid = true;
#ifndef HAVE_STOKHOS_DAKOTA
sparse_grid = false;
#endif
Teuchos::Array<double> mean(np), mean_st(np), std_dev(np), std_dev_st(np);
Teuchos::Array<double> pt(np), pt_st(np);
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(d);
Teuchos::Array<double> eval_pt(d, 0.56789);
double pt_true;
// Loop over orders
int n = 0;
for (int p=pmin; p<=pmax; p++) {
std::cout << "p = " << p << std::endl;
// Create product basis
for (int i=0; i<d; i++)
bases[i] = Teuchos::rcp(new basis_type(p));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
// Create approximation
Stokhos::OrthogPolyApprox<int,double> s(basis), t1(basis), t2(basis);
Teuchos::Array< Stokhos::OrthogPolyApprox<int,double>* > xi(d);
for (int i=0; i<d; i++) {
xi[i] = new Stokhos::OrthogPolyApprox<int,double>(basis);
xi[i]->term(i, 1) = 1.0;
}
// Quadrature
Teuchos::RCP<const Stokhos::Quadrature<int,double> > quad;
#ifdef HAVE_STOKHOS_DAKOTA
if (sparse_grid)
quad =
Teuchos::rcp(new Stokhos::SparseGridQuadrature<int,double>(basis, p));
#endif
if (!sparse_grid)
quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(basis));
// Triple product tensor
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk =
basis->computeTripleProductTensor();
// Quadrature expansion
Stokhos::QuadOrthogPolyExpansion<int,double> quad_exp(basis, Cijk, quad);
// Compute PCE via quadrature expansion
s_quad_func<d> s_func(a);
const Stokhos::OrthogPolyApprox<int,double> **xip =
new const Stokhos::OrthogPolyApprox<int,double>*[d];
for (int i=0; i<d; i++)
xip[i] = xi[i];
quad_exp.nary_op(s_func,s,xip);
quad_exp.divide(t1,1.0,s);
delete [] xip;
// compute true point
Teuchos::Array<double> xx(d);
for (int i=0; i<d; i++)
xx[i] = xi[i]->evaluate(eval_pt);
pt_true = s_func(&(xx[0]));
pt_true = 1.0/pt_true;
// Compute Stieltjes basis
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > st_bases(1);
Teuchos::RCP< Stokhos::LanczosProjPCEBasis<int,double> > stp_basis_s;
Teuchos::RCP< Stokhos::LanczosPCEBasis<int,double> > st_basis_s;
if (lanczos) {
if (project_integrals) {
stp_basis_s =
Teuchos::rcp(new Stokhos::LanczosProjPCEBasis<int,double>(
p, Teuchos::rcp(&s,false), Cijk, normalize, true));
st_bases[0] = stp_basis_s;
}
else {
st_basis_s =
Teuchos::rcp(new Stokhos::LanczosPCEBasis<int,double>(
p, Teuchos::rcp(&s,false), quad, normalize, true));
st_bases[0] = st_basis_s;
}
}
else {
st_bases[0] =
Teuchos::rcp(new Stokhos::StieltjesPCEBasis<int,double>(
p, Teuchos::rcp(&s,false), quad, use_pce_quad_points,
normalize, project_integrals, Cijk));
}
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> >
st_basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(st_bases));
//std::cout << *st_basis << std::endl;
Stokhos::OrthogPolyApprox<int,double> s_st(st_basis), t_st(st_basis);
if (lanczos) {
if (project_integrals) {
s_st.term(0, 0) = stp_basis_s->getNewCoeffs(0);
s_st.term(0, 1) = stp_basis_s->getNewCoeffs(1);
}
else {
s_st.term(0, 0) = st_basis_s->getNewCoeffs(0);
s_st.term(0, 1) = st_basis_s->getNewCoeffs(1);
}
}
else {
s_st.term(0, 0) = s.mean();
s_st.term(0, 1) = 1.0;
}
// Triple product tensor
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > st_Cijk =
st_basis->computeTripleProductTensor();
// Tensor product quadrature
Teuchos::RCP<const Stokhos::Quadrature<int,double> > st_quad;
#ifdef HAVE_STOKHOS_DAKOTA
if (sparse_grid)
st_quad = Teuchos::rcp(new Stokhos::SparseGridQuadrature<int,double>(st_basis, p));
#endif
if (!sparse_grid)
st_quad = Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(st_basis));
// Quadrature expansion
Stokhos::QuadOrthogPolyExpansion<int,double> st_quad_exp(st_basis,
st_Cijk,
st_quad);
// Compute t_st = 1/s_st in Stieltjes basis
st_quad_exp.divide(t_st, 1.0, s_st);
// Project t_st back to original basis
pce_quad_func st_func(t_st, *st_basis);
quad_exp.unary_op(st_func, t2, s);
// std::cout.precision(12);
// std::cout << w;
// std::cout << w2;
// std::cout << w_st;
mean[n] = t1.mean();
mean_st[n] = t2.mean();
std_dev[n] = t1.standard_deviation();
std_dev_st[n] = t2.standard_deviation();
pt[n] = t1.evaluate(eval_pt);
pt_st[n] = t2.evaluate(eval_pt);
n++;
for (int i=0; i<d; i++)
delete xi[i];
}
n = 0;
int wi=10;
std::cout << "Statistical error:" << std::endl;
std::cout << "p "
<< std::setw(wi) << "mean" << " "
<< std::setw(wi) << "mean_st" << " "
<< std::setw(wi) << "std_dev" << " "
<< std::setw(wi) << "std_dev_st" << " "
<< std::setw(wi) << "point" << " "
<< std::setw(wi) << "point_st" << std::endl;
for (int p=pmin; p<pmax; p++) {
std::cout.precision(3);
std::cout.setf(std::ios::scientific);
std::cout << p << " "
<< std::setw(wi) << rel_err(mean[n], mean[np-1]) << " "
<< std::setw(wi) << rel_err(mean_st[n], mean[np-1]) << " "
<< std::setw(wi) << rel_err(std_dev[n], std_dev[np-1]) << " "
<< std::setw(wi) << rel_err(std_dev_st[n], std_dev[np-1])
<< " "
<< std::setw(wi) << rel_err(pt[n], pt_true) << " "
<< std::setw(wi) << rel_err(pt_st[n], pt_true)
<< std::endl;
n++;
}
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
}
int main(int argc, char *argv[]) {
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
// Create a communicator for Epetra objects
Teuchos::RCP<const Epetra_Comm> globalComm;
#ifdef HAVE_MPI
globalComm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
globalComm = Teuchos::rcp(new Epetra_SerialComm);
#endif
int MyPID = globalComm->MyPID();
try {
// Setup command line options
Teuchos::CommandLineProcessor CLP;
CLP.setDocString(
"This example runs a variety of stochastic Galerkin solvers.\n");
int n = 32;
CLP.setOption("num_mesh", &n, "Number of mesh points in each direction");
bool symmetric = false;
CLP.setOption("symmetric", "unsymmetric", &symmetric,
"Symmetric discretization");
int num_spatial_procs = -1;
CLP.setOption("num_spatial_procs", &num_spatial_procs, "Number of spatial processors (set -1 for all available procs)");
bool rebalance_stochastic_graph = false;
CLP.setOption("rebalance", "no-rebalance", &rebalance_stochastic_graph,
"Rebalance parallel stochastic graph (requires Isorropia)");
SG_RF randField = UNIFORM;
CLP.setOption("rand_field", &randField,
num_sg_rf, sg_rf_values, sg_rf_names,
"Random field type");
double mean = 0.2;
CLP.setOption("mean", &mean, "Mean");
double sigma = 0.1;
CLP.setOption("std_dev", &sigma, "Standard deviation");
double weightCut = 1.0;
CLP.setOption("weight_cut", &weightCut, "Weight cut");
int num_KL = 2;
CLP.setOption("num_kl", &num_KL, "Number of KL terms");
int p = 3;
CLP.setOption("order", &p, "Polynomial order");
bool normalize_basis = true;
CLP.setOption("normalize", "unnormalize", &normalize_basis,
"Normalize PC basis");
SG_Solver solve_method = SG_KRYLOV;
CLP.setOption("sg_solver", &solve_method,
num_sg_solver, sg_solver_values, sg_solver_names,
"SG solver method");
Krylov_Method outer_krylov_method = GMRES;
CLP.setOption("outer_krylov_method", &outer_krylov_method,
num_krylov_method, krylov_method_values, krylov_method_names,
"Outer Krylov method (for Krylov-based SG solver)");
Krylov_Solver outer_krylov_solver = AZTECOO;
CLP.setOption("outer_krylov_solver", &outer_krylov_solver,
num_krylov_solver, krylov_solver_values, krylov_solver_names,
"Outer linear solver");
double outer_tol = 1e-12;
CLP.setOption("outer_tol", &outer_tol, "Outer solver tolerance");
int outer_its = 1000;
CLP.setOption("outer_its", &outer_its, "Maximum outer iterations");
Krylov_Method inner_krylov_method = GMRES;
CLP.setOption("inner_krylov_method", &inner_krylov_method,
num_krylov_method, krylov_method_values, krylov_method_names,
"Inner Krylov method (for G-S, Jacobi, etc...)");
Krylov_Solver inner_krylov_solver = AZTECOO;
CLP.setOption("inner_krylov_solver", &inner_krylov_solver,
num_krylov_solver, krylov_solver_values, krylov_solver_names,
"Inner linear solver");
double inner_tol = 3e-13;
CLP.setOption("inner_tol", &inner_tol, "Inner solver tolerance");
int inner_its = 1000;
CLP.setOption("inner_its", &inner_its, "Maximum inner iterations");
SG_Op opMethod = MATRIX_FREE;
CLP.setOption("sg_operator_method", &opMethod,
num_sg_op, sg_op_values, sg_op_names,
"Operator method");
SG_Prec precMethod = AGS;
CLP.setOption("sg_prec_method", &precMethod,
num_sg_prec, sg_prec_values, sg_prec_names,
"Preconditioner method");
double gs_prec_tol = 1e-1;
CLP.setOption("gs_prec_tol", &gs_prec_tol, "Gauss-Seidel preconditioner tolerance");
int gs_prec_its = 1;
CLP.setOption("gs_prec_its", &gs_prec_its, "Maximum Gauss-Seidel preconditioner iterations");
CLP.parse( argc, argv );
if (MyPID == 0) {
std::cout << "Summary of command line options:" << std::endl
<< "\tnum_mesh = " << n << std::endl
<< "\tsymmetric = " << symmetric << std::endl
<< "\tnum_spatial_procs = " << num_spatial_procs << std::endl
<< "\trebalance = " << rebalance_stochastic_graph
<< std::endl
<< "\trand_field = " << sg_rf_names[randField]
<< std::endl
<< "\tmean = " << mean << std::endl
<< "\tstd_dev = " << sigma << std::endl
<< "\tweight_cut = " << weightCut << std::endl
<< "\tnum_kl = " << num_KL << std::endl
<< "\torder = " << p << std::endl
<< "\tnormalize_basis = " << normalize_basis << std::endl
<< "\tsg_solver = " << sg_solver_names[solve_method]
<< std::endl
<< "\touter_krylov_method = "
<< krylov_method_names[outer_krylov_method] << std::endl
<< "\touter_krylov_solver = "
<< krylov_solver_names[outer_krylov_solver] << std::endl
<< "\touter_tol = " << outer_tol << std::endl
<< "\touter_its = " << outer_its << std::endl
<< "\tinner_krylov_method = "
<< krylov_method_names[inner_krylov_method] << std::endl
<< "\tinner_krylov_solver = "
<< krylov_solver_names[inner_krylov_solver] << std::endl
<< "\tinner_tol = " << inner_tol << std::endl
<< "\tinner_its = " << inner_its << std::endl
<< "\tsg_operator_method = " << sg_op_names[opMethod]
<< std::endl
<< "\tsg_prec_method = " << sg_prec_names[precMethod]
<< std::endl
<< "\tgs_prec_tol = " << gs_prec_tol << std::endl
<< "\tgs_prec_its = " << gs_prec_its << std::endl;
}
bool nonlinear_expansion = false;
if (randField == UNIFORM || randField == RYS)
nonlinear_expansion = false;
else if (randField == LOGNORMAL)
nonlinear_expansion = true;
bool scaleOP = true;
{
TEUCHOS_FUNC_TIME_MONITOR("Total PCE Calculation Time");
// Create Stochastic Galerkin basis and expansion
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(num_KL);
for (int i=0; i<num_KL; i++)
if (randField == UNIFORM)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p,normalize_basis));
else if (randField == RYS)
bases[i] = Teuchos::rcp(new Stokhos::RysBasis<int,double>(p,weightCut,normalize_basis));
else if (randField == LOGNORMAL)
bases[i] = Teuchos::rcp(new Stokhos::HermiteBasis<int,double>(p,normalize_basis));
// bases[i] = Teuchos::rcp(new Stokhos::DiscretizedStieltjesBasis<int,double>("beta",p,&uniform_weight,-weightCut,weightCut,true));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
int sz = basis->size();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk;
if (nonlinear_expansion)
Cijk = basis->computeTripleProductTensor(sz);
else
Cijk = basis->computeTripleProductTensor(num_KL+1);
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > expansion =
Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<int,double>(basis,
Cijk));
if (MyPID == 0)
std::cout << "Stochastic Galerkin expansion size = " << sz << std::endl;
// Create stochastic parallel distribution
Teuchos::ParameterList parallelParams;
parallelParams.set("Number of Spatial Processors", num_spatial_procs);
parallelParams.set("Rebalance Stochastic Graph",
rebalance_stochastic_graph);
Teuchos::RCP<Stokhos::ParallelData> sg_parallel_data =
Teuchos::rcp(new Stokhos::ParallelData(basis, Cijk, globalComm,
parallelParams));
Teuchos::RCP<const EpetraExt::MultiComm> sg_comm =
sg_parallel_data->getMultiComm();
Teuchos::RCP<const Epetra_Comm> app_comm =
sg_parallel_data->getSpatialComm();
// Create application
Teuchos::RCP<twoD_diffusion_ME> model =
Teuchos::rcp(new twoD_diffusion_ME(app_comm, n, num_KL, sigma,
mean, basis, nonlinear_expansion,
symmetric));
// Set up NOX parameters
Teuchos::RCP<Teuchos::ParameterList> noxParams =
Teuchos::rcp(new Teuchos::ParameterList);
// Set the nonlinear solver method
noxParams->set("Nonlinear Solver", "Line Search Based");
// Set the printing parameters in the "Printing" sublist
Teuchos::ParameterList& printParams = noxParams->sublist("Printing");
printParams.set("MyPID", MyPID);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
//NOX::Utils::Parameters +
NOX::Utils::Details +
NOX::Utils::LinearSolverDetails +
NOX::Utils::Warning +
NOX::Utils::Error);
// Create printing utilities
NOX::Utils utils(printParams);
// Sublist for line search
Teuchos::ParameterList& searchParams = noxParams->sublist("Line Search");
searchParams.set("Method", "Full Step");
// Sublist for direction
Teuchos::ParameterList& dirParams = noxParams->sublist("Direction");
dirParams.set("Method", "Newton");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
newtonParams.set("Forcing Term Method", "Constant");
// Sublist for linear solver for the Newton method
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
// Alternative linear solver list for Stratimikos
Teuchos::ParameterList& stratLinSolParams =
newtonParams.sublist("Stratimikos Linear Solver");
// Teuchos::ParameterList& noxStratParams =
// stratLinSolParams.sublist("NOX Stratimikos Options");
Teuchos::ParameterList& stratParams =
stratLinSolParams.sublist("Stratimikos");
// Sublist for convergence tests
Teuchos::ParameterList& statusParams = noxParams->sublist("Status Tests");
statusParams.set("Test Type", "Combo");
statusParams.set("Number of Tests", 2);
statusParams.set("Combo Type", "OR");
Teuchos::ParameterList& normF = statusParams.sublist("Test 0");
normF.set("Test Type", "NormF");
normF.set("Tolerance", outer_tol);
normF.set("Scale Type", "Scaled");
Teuchos::ParameterList& maxIters = statusParams.sublist("Test 1");
maxIters.set("Test Type", "MaxIters");
maxIters.set("Maximum Iterations", 1);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> det_nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(model));
// Create NOX linear system object
Teuchos::RCP<const Epetra_Vector> det_u = model->get_x_init();
Teuchos::RCP<Epetra_Operator> det_A = model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> det_iReq = det_nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> det_iJac = det_nox_interface;
Teuchos::ParameterList det_printParams;
det_printParams.set("MyPID", MyPID);
det_printParams.set("Output Precision", 3);
det_printParams.set("Output Processor", 0);
det_printParams.set("Output Information", NOX::Utils::Error);
Teuchos::ParameterList det_lsParams;
Teuchos::ParameterList& det_stratParams =
det_lsParams.sublist("Stratimikos");
if (inner_krylov_solver == AZTECOO) {
det_stratParams.set("Linear Solver Type", "AztecOO");
Teuchos::ParameterList& aztecOOParams =
det_stratParams.sublist("Linear Solver Types").sublist("AztecOO").sublist("Forward Solve");
Teuchos::ParameterList& aztecOOSettings =
aztecOOParams.sublist("AztecOO Settings");
if (inner_krylov_method == GMRES) {
aztecOOSettings.set("Aztec Solver","GMRES");
}
else if (inner_krylov_method == CG) {
aztecOOSettings.set("Aztec Solver","CG");
}
aztecOOSettings.set("Output Frequency", 0);
aztecOOSettings.set("Size of Krylov Subspace", 100);
aztecOOParams.set("Max Iterations", inner_its);
aztecOOParams.set("Tolerance", inner_tol);
Teuchos::ParameterList& verbParams =
det_stratParams.sublist("Linear Solver Types").sublist("AztecOO").sublist("VerboseObject");
verbParams.set("Verbosity Level", "none");
}
else if (inner_krylov_solver == BELOS) {
det_stratParams.set("Linear Solver Type", "Belos");
Teuchos::ParameterList& belosParams =
det_stratParams.sublist("Linear Solver Types").sublist("Belos");
Teuchos::ParameterList* belosSolverParams = NULL;
if (inner_krylov_method == GMRES || inner_krylov_method == FGMRES) {
belosParams.set("Solver Type","Block GMRES");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block GMRES"));
if (inner_krylov_method == FGMRES)
belosSolverParams->set("Flexible Gmres", true);
}
else if (inner_krylov_method == CG) {
belosParams.set("Solver Type","Block CG");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block CG"));
}
else if (inner_krylov_method == RGMRES) {
belosParams.set("Solver Type","GCRODR");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("GCRODR"));
}
belosSolverParams->set("Convergence Tolerance", inner_tol);
belosSolverParams->set("Maximum Iterations", inner_its);
belosSolverParams->set("Output Frequency",0);
belosSolverParams->set("Output Style",1);
belosSolverParams->set("Verbosity",0);
Teuchos::ParameterList& verbParams = belosParams.sublist("VerboseObject");
verbParams.set("Verbosity Level", "none");
}
det_stratParams.set("Preconditioner Type", "ML");
Teuchos::ParameterList& det_ML =
det_stratParams.sublist("Preconditioner Types").sublist("ML").sublist("ML Settings");
ML_Epetra::SetDefaults("SA", det_ML);
det_ML.set("ML output", 0);
det_ML.set("max levels",5);
det_ML.set("increasing or decreasing","increasing");
det_ML.set("aggregation: type", "Uncoupled");
det_ML.set("smoother: type","ML symmetric Gauss-Seidel");
det_ML.set("smoother: sweeps",2);
det_ML.set("smoother: pre or post", "both");
det_ML.set("coarse: max size", 200);
#ifdef HAVE_ML_AMESOS
det_ML.set("coarse: type","Amesos-KLU");
#else
det_ML.set("coarse: type","Jacobi");
#endif
Teuchos::RCP<NOX::Epetra::LinearSystem> det_linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
det_printParams, det_lsParams, det_iJac,
det_A, *det_u));
// Setup stochastic Galerkin algorithmic parameters
Teuchos::RCP<Teuchos::ParameterList> sgParams =
Teuchos::rcp(new Teuchos::ParameterList);
Teuchos::ParameterList& sgOpParams =
sgParams->sublist("SG Operator");
Teuchos::ParameterList& sgPrecParams =
sgParams->sublist("SG Preconditioner");
if (!nonlinear_expansion) {
sgParams->set("Parameter Expansion Type", "Linear");
sgParams->set("Jacobian Expansion Type", "Linear");
}
if (opMethod == MATRIX_FREE)
sgOpParams.set("Operator Method", "Matrix Free");
else if (opMethod == KL_MATRIX_FREE)
sgOpParams.set("Operator Method", "KL Matrix Free");
else if (opMethod == KL_REDUCED_MATRIX_FREE) {
sgOpParams.set("Operator Method", "KL Reduced Matrix Free");
if (randField == UNIFORM || randField == RYS)
sgOpParams.set("Number of KL Terms", num_KL);
else
sgOpParams.set("Number of KL Terms", basis->size());
sgOpParams.set("KL Tolerance", outer_tol);
sgOpParams.set("Sparse 3 Tensor Drop Tolerance", outer_tol);
sgOpParams.set("Do Error Tests", true);
}
else if (opMethod == FULLY_ASSEMBLED)
sgOpParams.set("Operator Method", "Fully Assembled");
else
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
"Error! Unknown operator method " << opMethod
<< "." << std::endl);
if (precMethod == MEAN) {
sgPrecParams.set("Preconditioner Method", "Mean-based");
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
}
else if(precMethod == GS) {
sgPrecParams.set("Preconditioner Method", "Gauss-Seidel");
sgPrecParams.sublist("Deterministic Solver Parameters") = det_lsParams;
sgPrecParams.set("Deterministic Solver", det_linsys);
sgPrecParams.set("Max Iterations", gs_prec_its);
sgPrecParams.set("Tolerance", gs_prec_tol);
}
else if (precMethod == AGS) {
sgPrecParams.set("Preconditioner Method", "Approximate Gauss-Seidel");
if (outer_krylov_method == CG)
sgPrecParams.set("Symmetric Gauss-Seidel", true);
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
}
else if (precMethod == AJ) {
sgPrecParams.set("Preconditioner Method", "Approximate Jacobi");
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
Teuchos::ParameterList& jacobiOpParams =
sgPrecParams.sublist("Jacobi SG Operator");
jacobiOpParams.set("Only Use Linear Terms", true);
}
else if (precMethod == ASC) {
sgPrecParams.set("Preconditioner Method", "Approximate Schur Complement");
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
}
else if (precMethod == KP) {
sgPrecParams.set("Preconditioner Method", "Kronecker Product");
sgPrecParams.set("Only Use Linear Terms", true);
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& meanPrecParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
meanPrecParams = det_ML;
sgPrecParams.set("G Preconditioner Type", "Ifpack");
Teuchos::ParameterList& GPrecParams =
sgPrecParams.sublist("G Preconditioner Parameters");
if (outer_krylov_method == GMRES || outer_krylov_method == FGMRES)
GPrecParams.set("Ifpack Preconditioner", "ILUT");
if (outer_krylov_method == CG)
GPrecParams.set("Ifpack Preconditioner", "ICT");
GPrecParams.set("Overlap", 1);
GPrecParams.set("fact: drop tolerance", 1e-4);
GPrecParams.set("fact: ilut level-of-fill", 1.0);
GPrecParams.set("schwarz: combine mode", "Add");
}
else if (precMethod == NONE) {
sgPrecParams.set("Preconditioner Method", "None");
}
else
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
"Error! Unknown preconditioner method " << precMethod
<< "." << std::endl);
// Create stochastic Galerkin model evaluator
Teuchos::RCP<Stokhos::SGModelEvaluator> sg_model =
Teuchos::rcp(new Stokhos::SGModelEvaluator(model, basis, Teuchos::null,
expansion, sg_parallel_data,
sgParams, scaleOP));
EpetraExt::ModelEvaluator::InArgs sg_inArgs = sg_model->createInArgs();
EpetraExt::ModelEvaluator::OutArgs sg_outArgs =
sg_model->createOutArgs();
// Set up stochastic parameters
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_p_init =
sg_model->create_p_sg(0);
for (int i=0; i<num_KL; i++) {
sg_p_init->term(i,0)[i] = 0.0;
sg_p_init->term(i,1)[i] = 1.0;
}
sg_model->set_p_sg_init(0, *sg_p_init);
// Setup stochastic initial guess
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_init =
sg_model->create_x_sg();
sg_x_init->init(0.0);
sg_model->set_x_sg_init(*sg_x_init);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(sg_model));
// Create NOX stochastic linear system object
Teuchos::RCP<const Epetra_Vector> u = sg_model->get_x_init();
Teuchos::RCP<const Epetra_Map> base_map = model->get_x_map();
Teuchos::RCP<const Epetra_Map> sg_map = sg_model->get_x_map();
Teuchos::RCP<Epetra_Operator> A = sg_model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = nox_interface;
// Build linear solver
Teuchos::RCP<NOX::Epetra::LinearSystem> linsys;
if (solve_method==SG_KRYLOV) {
bool has_M =
sg_outArgs.supports(EpetraExt::ModelEvaluator::OUT_ARG_WPrec);
Teuchos::RCP<Epetra_Operator> M;
Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec;
if (has_M) {
M = sg_model->create_WPrec()->PrecOp;
iPrec = nox_interface;
}
stratParams.set("Preconditioner Type", "None");
if (outer_krylov_solver == AZTECOO) {
stratParams.set("Linear Solver Type", "AztecOO");
Teuchos::ParameterList& aztecOOParams =
stratParams.sublist("Linear Solver Types").sublist("AztecOO").sublist("Forward Solve");
Teuchos::ParameterList& aztecOOSettings =
aztecOOParams.sublist("AztecOO Settings");
if (outer_krylov_method == GMRES) {
aztecOOSettings.set("Aztec Solver","GMRES");
}
else if (outer_krylov_method == CG) {
aztecOOSettings.set("Aztec Solver","CG");
}
aztecOOSettings.set("Output Frequency", 1);
aztecOOSettings.set("Size of Krylov Subspace", 100);
aztecOOParams.set("Max Iterations", outer_its);
aztecOOParams.set("Tolerance", outer_tol);
stratLinSolParams.set("Preconditioner", "User Defined");
if (has_M)
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, iPrec, M,
*u, true));
else
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, *u));
}
else if (outer_krylov_solver == BELOS){
stratParams.set("Linear Solver Type", "Belos");
Teuchos::ParameterList& belosParams =
stratParams.sublist("Linear Solver Types").sublist("Belos");
Teuchos::ParameterList* belosSolverParams = NULL;
if (outer_krylov_method == GMRES || outer_krylov_method == FGMRES) {
belosParams.set("Solver Type","Block GMRES");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block GMRES"));
if (outer_krylov_method == FGMRES)
belosSolverParams->set("Flexible Gmres", true);
}
else if (outer_krylov_method == CG) {
belosParams.set("Solver Type","Block CG");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block CG"));
}
else if (inner_krylov_method == RGMRES) {
belosParams.set("Solver Type","GCRODR");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("GCRODR"));
}
belosSolverParams->set("Convergence Tolerance", outer_tol);
belosSolverParams->set("Maximum Iterations", outer_its);
belosSolverParams->set("Output Frequency",1);
belosSolverParams->set("Output Style",1);
belosSolverParams->set("Verbosity",33);
stratLinSolParams.set("Preconditioner", "User Defined");
if (has_M)
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, iPrec, M,
*u, true));
else
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, *u));
}
}
else if (solve_method==SG_GS) {
lsParams.sublist("Deterministic Solver Parameters") = det_lsParams;
lsParams.set("Max Iterations", outer_its);
lsParams.set("Tolerance", outer_tol);
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemSGGS(
printParams, lsParams, det_linsys, iReq, iJac,
basis, sg_parallel_data, A, base_map, sg_map));
}
else {
lsParams.sublist("Deterministic Solver Parameters") = det_lsParams;
lsParams.set("Max Iterations", outer_its);
lsParams.set("Tolerance", outer_tol);
Teuchos::ParameterList& jacobiOpParams =
lsParams.sublist("Jacobi SG Operator");
jacobiOpParams.set("Only Use Linear Terms", true);
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemSGJacobi(
printParams, lsParams, det_linsys, iReq, iJac,
basis, sg_parallel_data, A, base_map, sg_map));
}
// Build NOX group
Teuchos::RCP<NOX::Epetra::Group> grp =
Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, *u, linsys));
// Create the Solver convergence test
Teuchos::RCP<NOX::StatusTest::Generic> statusTests =
NOX::StatusTest::buildStatusTests(statusParams, utils);
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(grp, statusTests, noxParams);
// Solve the system
NOX::StatusTest::StatusType status;
{
TEUCHOS_FUNC_TIME_MONITOR("Total Solve Time");
status = solver->solve();
}
// Get final solution
const NOX::Epetra::Group& finalGroup =
dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
const Epetra_Vector& finalSolution =
(dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX())).getEpetraVector();
// Save final solution to file
EpetraExt::VectorToMatrixMarketFile("nox_solver_stochastic_solution.mm",
finalSolution);
// Save mean and variance to file
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_poly =
sg_model->create_x_sg(View, &finalSolution);
Epetra_Vector mean(*(model->get_x_map()));
Epetra_Vector std_dev(*(model->get_x_map()));
sg_x_poly->computeMean(mean);
sg_x_poly->computeStandardDeviation(std_dev);
EpetraExt::VectorToMatrixMarketFile("mean_gal.mm", mean);
EpetraExt::VectorToMatrixMarketFile("std_dev_gal.mm", std_dev);
// Evaluate SG responses at SG parameters
Teuchos::RCP<const Epetra_Vector> sg_p = sg_model->get_p_init(1);
Teuchos::RCP<Epetra_Vector> sg_g =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_g_map(0))));
sg_inArgs.set_p(1, sg_p);
sg_inArgs.set_x(Teuchos::rcp(&finalSolution,false));
sg_outArgs.set_g(0, sg_g);
sg_model->evalModel(sg_inArgs, sg_outArgs);
// Print mean and standard deviation of response
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_g_poly =
sg_model->create_g_sg(0, View, sg_g.get());
Epetra_Vector g_mean(*(model->get_g_map(0)));
Epetra_Vector g_std_dev(*(model->get_g_map(0)));
sg_g_poly->computeMean(g_mean);
sg_g_poly->computeStandardDeviation(g_std_dev);
std::cout.precision(16);
// std::cout << "\nResponse Expansion = " << std::endl;
// std::cout.precision(12);
// sg_g_poly->print(std::cout);
std::cout << "\nResponse Mean = " << std::endl << g_mean << std::endl;
std::cout << "Response Std. Dev. = " << std::endl << g_std_dev << std::endl;
if (status == NOX::StatusTest::Converged && MyPID == 0)
utils.out() << "Example Passed!" << std::endl;
}
Teuchos::TimeMonitor::summarize(std::cout);
Teuchos::TimeMonitor::zeroOutTimers();
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (string& s) {
std::cout << s << std::endl;
}
catch (char *s) {
std::cout << s << std::endl;
}
catch (...) {
std::cout << "Caught unknown exception!" <<std:: endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
}
int main(int argc, char **argv)
{
try {
const unsigned int d = 2;
const unsigned int pmin = 2;
const unsigned int pmax = 10;
const unsigned int np = pmax-pmin+1;
bool use_pce_quad_points = false;
bool normalize = true;
bool sparse_grid = true;
bool project_integrals = false;
#ifndef HAVE_STOKHOS_DAKOTA
sparse_grid = false;
#endif
Teuchos::Array<double> mean(np), mean_st(np), std_dev(np), std_dev_st(np);
Teuchos::Array<double> pt(np), pt_st(np);
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(d);
Teuchos::Array<double> eval_pt(d, 0.5);
double pt_true;
// Loop over orders
unsigned int n = 0;
for (unsigned int p=pmin; p<=pmax; p++) {
std::cout << "p = " << p << std::endl;
// Create product basis
for (unsigned int i=0; i<d; i++)
bases[i] = Teuchos::rcp(new basis_type(p));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
// Create approximation
Stokhos::OrthogPolyApprox<int,double> x(basis), u(basis), v(basis),
w(basis), w2(basis);
for (unsigned int i=0; i<d; i++) {
x.term(i, 1) = 1.0;
}
double x_pt = x.evaluate(eval_pt);
pt_true = std::exp(std::sin(x_pt));
// Quadrature
Teuchos::RCP<const Stokhos::Quadrature<int,double> > quad;
#ifdef HAVE_STOKHOS_DAKOTA
if (sparse_grid)
quad =
Teuchos::rcp(new Stokhos::SparseGridQuadrature<int,double>(basis, p));
#endif
if (!sparse_grid)
quad =
Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(basis));
// Triple product tensor
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk =
basis->computeTripleProductTensor(basis->size());
// Quadrature expansion
Stokhos::QuadOrthogPolyExpansion<int,double> quad_exp(basis, Cijk, quad);
// Compute PCE via quadrature expansion
quad_exp.sin(u,x);
//quad_exp.times(u,u,10.0);
quad_exp.exp(w,u);
// Compute Stieltjes basis
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > st_bases(1);
Teuchos::RCP<const Stokhos::LanczosProjPCEBasis<int,double> > st_1d_basis
= Teuchos::rcp(new Stokhos::LanczosProjPCEBasis<int,double>(
p, Teuchos::rcp(&u,false), Cijk, normalize));
st_bases[0] = st_1d_basis;
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> >
st_basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(st_bases));
//std::cout << *st_basis << std::endl;
Stokhos::OrthogPolyApprox<int,double> u_st(st_basis), w_st(st_basis);
u_st.term(0, 0) = st_1d_basis->getNewCoeffs(0);
u_st.term(0, 1) = st_1d_basis->getNewCoeffs(1);
// Triple product tensor
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > st_Cijk =
st_basis->computeTripleProductTensor(st_basis->size());
// Tensor product quadrature
Teuchos::RCP<const Stokhos::Quadrature<int,double> > st_quad;
if (!use_pce_quad_points) {
#ifdef HAVE_STOKHOS_DAKOTA
if (sparse_grid)
st_quad = Teuchos::rcp(new Stokhos::SparseGridQuadrature<int,double>(st_basis, p));
#endif
if (!sparse_grid)
st_quad = Teuchos::rcp(new Stokhos::TensorProductQuadrature<int,double>(st_basis));
}
else {
Teuchos::Array<double> st_points_0;
Teuchos::Array<double> st_weights_0;
Teuchos::Array< Teuchos::Array<double> > st_values_0;
st_bases[0]->getQuadPoints(p+1, st_points_0, st_weights_0, st_values_0);
Teuchos::Array<double> st_points_1;
Teuchos::Array<double> st_weights_1;
Teuchos::Array< Teuchos::Array<double> > st_values_1;
st_bases[1]->getQuadPoints(p+1, st_points_1, st_weights_1, st_values_1);
Teuchos::RCP< Teuchos::Array< Teuchos::Array<double> > > st_points =
Teuchos::rcp(new Teuchos::Array< Teuchos::Array<double> >(st_points_0.size()));
for (int i=0; i<st_points_0.size(); i++) {
(*st_points)[i].resize(2);
(*st_points)[i][0] = st_points_0[i];
(*st_points)[i][1] = st_points_1[i];
}
Teuchos::RCP< Teuchos::Array<double> > st_weights =
Teuchos::rcp(new Teuchos::Array<double>(st_weights_0));
Teuchos::RCP< const Stokhos::OrthogPolyBasis<int,double> > st_b =
st_basis;
st_quad =
Teuchos::rcp(new Stokhos::UserDefinedQuadrature<int,double>(st_b,
st_points,
st_weights));
}
// Quadrature expansion
Stokhos::QuadOrthogPolyExpansion<int,double> st_quad_exp(st_basis,
st_Cijk,
st_quad);
// Compute w_st = u_st*v_st in Stieltjes basis
st_quad_exp.exp(w_st, u_st);
// Project w_st back to original basis
pce_quad_func st_func(w_st, *st_basis);
quad_exp.unary_op(st_func, w2, u);
// std::cout.precision(12);
// std::cout << w;
// std::cout << w2;
// std::cout << w_st;
mean[n] = w.mean();
mean_st[n] = w2.mean();
std_dev[n] = w.standard_deviation();
std_dev_st[n] = w2.standard_deviation();
pt[n] = w.evaluate(eval_pt);
pt_st[n] = w2.evaluate(eval_pt);
n++;
}
n = 0;
int wi=10;
std::cout << "Statistical error:" << std::endl;
std::cout << "p "
<< std::setw(wi) << "mean" << " "
<< std::setw(wi) << "mean_st" << " "
<< std::setw(wi) << "std_dev" << " "
<< std::setw(wi) << "std_dev_st" << " "
<< std::setw(wi) << "point" << " "
<< std::setw(wi) << "point_st" << std::endl;
for (unsigned int p=pmin; p<pmax; p++) {
std::cout.precision(3);
std::cout.setf(std::ios::scientific);
std::cout << p << " "
<< std::setw(wi) << rel_err(mean[n], mean[np-1]) << " "
<< std::setw(wi) << rel_err(mean_st[n], mean[np-1]) << " "
<< std::setw(wi) << rel_err(std_dev[n], std_dev[np-1]) << " "
<< std::setw(wi) << rel_err(std_dev_st[n], std_dev[np-1])
<< " "
<< std::setw(wi) << rel_err(pt[n], pt_true) << " "
<< std::setw(wi) << rel_err(pt_st[n], pt_true)
<< std::endl;
n++;
}
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
}
int main(int argc, char *argv[]) {
int n = 32; // spatial discretization (per dimension)
int num_KL = 2; // number of KL terms
int p = 3; // polynomial order
double mu = 0.1; // mean of exponential random field
double s = 0.2; // std. dev. of exponential r.f.
bool nonlinear_expansion = false; // nonlinear expansion of diffusion coeff
// (e.g., log-normal)
bool matrix_free = true; // use matrix-free stochastic operator
bool symmetric = false; // use symmetric formulation
double g_mean_exp = 0.172988; // expected response mean
double g_std_dev_exp = 0.0380007; // expected response std. dev.
double g_tol = 1e-6; // tolerance on determining success
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
int MyPID;
try {
{
TEUCHOS_FUNC_TIME_MONITOR("Total PCE Calculation Time");
// Create a communicator for Epetra objects
Teuchos::RCP<const Epetra_Comm> globalComm;
#ifdef HAVE_MPI
globalComm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
globalComm = Teuchos::rcp(new Epetra_SerialComm);
#endif
MyPID = globalComm->MyPID();
// Create Stochastic Galerkin basis and expansion
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(num_KL);
for (int i=0; i<num_KL; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p, true));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
int sz = basis->size();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk;
if (nonlinear_expansion)
Cijk = basis->computeTripleProductTensor();
else
Cijk = basis->computeLinearTripleProductTensor();
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > expansion =
Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<int,double>(basis,
Cijk));
if (MyPID == 0)
std::cout << "Stochastic Galerkin expansion size = " << sz << std::endl;
// Create stochastic parallel distribution
int num_spatial_procs = -1;
if (argc > 1)
num_spatial_procs = std::atoi(argv[1]);
Teuchos::ParameterList parallelParams;
parallelParams.set("Number of Spatial Processors", num_spatial_procs);
Teuchos::RCP<Stokhos::ParallelData> sg_parallel_data =
Teuchos::rcp(new Stokhos::ParallelData(basis, Cijk, globalComm,
parallelParams));
Teuchos::RCP<const EpetraExt::MultiComm> sg_comm =
sg_parallel_data->getMultiComm();
Teuchos::RCP<const Epetra_Comm> app_comm =
sg_parallel_data->getSpatialComm();
// Create application
Teuchos::RCP<twoD_diffusion_ME> model =
Teuchos::rcp(new twoD_diffusion_ME(app_comm, n, num_KL, mu, s, basis,
nonlinear_expansion, symmetric));
// Setup stochastic Galerkin algorithmic parameters
Teuchos::RCP<Teuchos::ParameterList> sgParams =
Teuchos::rcp(new Teuchos::ParameterList);
Teuchos::ParameterList& sgOpParams =
sgParams->sublist("SG Operator");
Teuchos::ParameterList& sgPrecParams =
sgParams->sublist("SG Preconditioner");
if (!nonlinear_expansion) {
sgParams->set("Parameter Expansion Type", "Linear");
sgParams->set("Jacobian Expansion Type", "Linear");
}
if (matrix_free) {
sgOpParams.set("Operator Method", "Matrix Free");
sgPrecParams.set("Preconditioner Method", "Approximate Gauss-Seidel");
sgPrecParams.set("Symmetric Gauss-Seidel", symmetric);
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams.set("default values", "SA");
precParams.set("ML output", 0);
precParams.set("max levels",5);
precParams.set("increasing or decreasing","increasing");
precParams.set("aggregation: type", "Uncoupled");
precParams.set("smoother: type","ML symmetric Gauss-Seidel");
precParams.set("smoother: sweeps",2);
precParams.set("smoother: pre or post", "both");
precParams.set("coarse: max size", 200);
#ifdef HAVE_ML_AMESOS
precParams.set("coarse: type","Amesos-KLU");
#else
precParams.set("coarse: type","Jacobi");
#endif
}
else {
sgOpParams.set("Operator Method", "Fully Assembled");
sgPrecParams.set("Preconditioner Method", "None");
}
// Create stochastic Galerkin model evaluator
Teuchos::RCP<Stokhos::SGModelEvaluator> sg_model =
Teuchos::rcp(new Stokhos::SGModelEvaluator(model, basis, Teuchos::null,
expansion, sg_parallel_data,
sgParams));
// Set up stochastic parameters
// The current implementation of the model doesn't actually use these
// values, but is hard-coded to certain uncertainty models
Teuchos::Array<double> point(num_KL, 1.0);
Teuchos::Array<double> basis_vals(sz);
basis->evaluateBases(point, basis_vals);
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_p_init =
sg_model->create_p_sg(0);
for (int i=0; i<num_KL; i++) {
sg_p_init->term(i,0)[i] = 0.0;
sg_p_init->term(i,1)[i] = 1.0 / basis_vals[i+1];
}
sg_model->set_p_sg_init(0, *sg_p_init);
// Setup stochastic initial guess
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_init =
sg_model->create_x_sg();
sg_x_init->init(0.0);
sg_model->set_x_sg_init(*sg_x_init);
// Set up NOX parameters
Teuchos::RCP<Teuchos::ParameterList> noxParams =
Teuchos::rcp(new Teuchos::ParameterList);
// Set the nonlinear solver method
noxParams->set("Nonlinear Solver", "Line Search Based");
// Set the printing parameters in the "Printing" sublist
Teuchos::ParameterList& printParams = noxParams->sublist("Printing");
printParams.set("MyPID", MyPID);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
NOX::Utils::LinearSolverDetails +
NOX::Utils::Warning +
NOX::Utils::Error);
// Create printing utilities
NOX::Utils utils(printParams);
// Sublist for line search
Teuchos::ParameterList& searchParams = noxParams->sublist("Line Search");
searchParams.set("Method", "Full Step");
// Sublist for direction
Teuchos::ParameterList& dirParams = noxParams->sublist("Direction");
dirParams.set("Method", "Newton");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
newtonParams.set("Forcing Term Method", "Constant");
// Sublist for linear solver for the Newton method
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
if (symmetric)
lsParams.set("Aztec Solver", "CG");
else
lsParams.set("Aztec Solver", "GMRES");
lsParams.set("Max Iterations", 1000);
lsParams.set("Size of Krylov Subspace", 100);
lsParams.set("Tolerance", 1e-12);
lsParams.set("Output Frequency", 1);
if (matrix_free)
lsParams.set("Preconditioner", "User Defined");
else {
lsParams.set("Preconditioner", "ML");
Teuchos::ParameterList& precParams =
lsParams.sublist("ML");
ML_Epetra::SetDefaults("DD", precParams);
lsParams.set("Write Linear System", false);
}
// Sublist for convergence tests
Teuchos::ParameterList& statusParams = noxParams->sublist("Status Tests");
statusParams.set("Test Type", "Combo");
statusParams.set("Number of Tests", 2);
statusParams.set("Combo Type", "OR");
Teuchos::ParameterList& normF = statusParams.sublist("Test 0");
normF.set("Test Type", "NormF");
normF.set("Tolerance", 1e-10);
normF.set("Scale Type", "Scaled");
Teuchos::ParameterList& maxIters = statusParams.sublist("Test 1");
maxIters.set("Test Type", "MaxIters");
maxIters.set("Maximum Iterations", 1);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(sg_model));
// Create NOX linear system object
Teuchos::RCP<const Epetra_Vector> u = sg_model->get_x_init();
Teuchos::RCP<Epetra_Operator> A = sg_model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = nox_interface;
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linsys;
if (matrix_free) {
Teuchos::RCP<Epetra_Operator> M = sg_model->create_WPrec()->PrecOp;
Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec = nox_interface;
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iJac, A, iPrec, M,
*u));
}
else {
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iReq, iJac, A,
*u));
}
// Build NOX group
Teuchos::RCP<NOX::Epetra::Group> grp =
Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, *u, linsys));
// Create the Solver convergence test
Teuchos::RCP<NOX::StatusTest::Generic> statusTests =
NOX::StatusTest::buildStatusTests(statusParams, utils);
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(grp, statusTests, noxParams);
// Solve the system
NOX::StatusTest::StatusType status = solver->solve();
// Get final solution
const NOX::Epetra::Group& finalGroup =
dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
const Epetra_Vector& finalSolution =
(dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX())).getEpetraVector();
// Save final solution to file
EpetraExt::VectorToMatrixMarketFile("nox_stochastic_solution.mm",
finalSolution);
// Save mean and variance to file
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_poly =
sg_model->create_x_sg(View, &finalSolution);
Epetra_Vector mean(*(model->get_x_map()));
Epetra_Vector std_dev(*(model->get_x_map()));
sg_x_poly->computeMean(mean);
sg_x_poly->computeStandardDeviation(std_dev);
EpetraExt::VectorToMatrixMarketFile("mean_gal.mm", mean);
EpetraExt::VectorToMatrixMarketFile("std_dev_gal.mm", std_dev);
// Evaluate SG responses at SG parameters
EpetraExt::ModelEvaluator::InArgs sg_inArgs = sg_model->createInArgs();
EpetraExt::ModelEvaluator::OutArgs sg_outArgs =
sg_model->createOutArgs();
Teuchos::RCP<const Epetra_Vector> sg_p = sg_model->get_p_init(1);
Teuchos::RCP<Epetra_Vector> sg_g =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_g_map(0))));
sg_inArgs.set_p(1, sg_p);
sg_inArgs.set_x(Teuchos::rcp(&finalSolution,false));
sg_outArgs.set_g(0, sg_g);
sg_model->evalModel(sg_inArgs, sg_outArgs);
// Print mean and standard deviation of response
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_g_poly =
sg_model->create_g_sg(0, View, sg_g.get());
Epetra_Vector g_mean(*(model->get_g_map(0)));
Epetra_Vector g_std_dev(*(model->get_g_map(0)));
sg_g_poly->computeMean(g_mean);
sg_g_poly->computeStandardDeviation(g_std_dev);
std::cout.precision(16);
// std::cout << "\nResponse Expansion = " << std::endl;
// std::cout.precision(12);
// sg_g_poly->print(std::cout);
std::cout << std::endl;
std::cout << "Response Mean = " << std::endl << g_mean << std::endl;
std::cout << "Response Std. Dev. = " << std::endl << g_std_dev << std::endl;
// Determine if example passed
bool passed = false;
if (status == NOX::StatusTest::Converged &&
std::abs(g_mean[0]-g_mean_exp) < g_tol &&
std::abs(g_std_dev[0]-g_std_dev_exp) < g_tol)
passed = true;
if (MyPID == 0) {
if (passed)
std::cout << "Example Passed!" << std::endl;
else
std::cout << "Example Failed!" << std::endl;
}
}
Teuchos::TimeMonitor::summarize(std::cout);
Teuchos::TimeMonitor::zeroOutTimers();
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (string& s) {
std::cout << s << std::endl;
}
catch (char *s) {
std::cout << s << std::endl;
}
catch (...) {
std::cout << "Caught unknown exception!" <<std:: endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
}
template <typename MatElem> cv::Mat _generateGaussianMask(const cv::Mat& covariance, double ignore_rate){
assert(skl::checkMat(covariance,-1,1,cv::Size(2,2)));
cv::Mat Wvec,U,Vt;
cv::SVD svd;
svd.compute(covariance,Wvec,U,Vt);
cv::Mat W(covariance.size(),covariance.type());
std::vector<MatElem> std_dev(W.rows);
for(int i=0;i<W.rows;i++){
std_dev[i] = (MatElem)std::sqrt((double)Wvec.at<MatElem>(i,0));
}
// mask size must be odd num
cv::Point center(
static_cast<int>(std_dev[0] * ignore_rate/2),
static_cast<int>(std_dev[1] * ignore_rate/2));
cv::Size mask_size(
center.x*2+1,
center.y*2+1);
cv::Mat gaussian_x = cv::getGaussianKernel(mask_size.width ,-1, covariance.depth());
cv::Mat gaussian_y = cv::getGaussianKernel(mask_size.height,-1, covariance.depth());
cv::Mat gaussian_mask = gaussian_y * gaussian_x.t();
/* for(int i=0;i<Wvec.rows;i++){
W.at<MatElem>(i,i) = Wvec.at<MatElem>(i,0);
}
std::cout << "covariance >> " << covariance << std::endl;
std::cout << "W >> " << W << std::endl;
std::cout << "U >> " << U << std::endl;
std::cout << "Vt >> " << Vt << std::endl;
std::cout << (U*W*Vt) << std::endl;
*/
float rad = skl::radian(cv::Point2f(U.at<MatElem>(0,0),U.at<MatElem>(0,1)));
float degree = rad*180/CV_PI;
// std::cout << "gausiann rotation: " << degree << std::endl;
/*
// DEBUG CODE: draw vertical/horizontal lines crossing at the center.
for(int x=0;x<gaussian_mask.cols;x++){
gaussian_mask.at<MatElem>(center.y,x) = 1;
}
for(int y=0;y<gaussian_mask.rows;y++){
gaussian_mask.at<MatElem>(y,center.x) = 1;
}
*/
// rotate gaussian mask
int max_length = std::max(mask_size.width,mask_size.height);
cv::Size dist_size(max_length,max_length);
cv::Mat gaussian_mask_max_length(dist_size,gaussian_mask.type(),cv::Scalar(0));
int diff_x = max_length - mask_size.width;
int diff_y = max_length - mask_size.height;
gaussian_mask.copyTo(
cv::Mat(
gaussian_mask_max_length,
cv::Rect(diff_x/2,diff_y/2,mask_size.width,mask_size.height)
)
);
cv::Mat affin_mat = cv::getRotationMatrix2D(cv::Point(max_length/2,max_length/2),degree,1.0);
// std::cout << affin_mat << std::endl;
cv::Mat gaussian_mask_rotated;
/*
cv::namedWindow("before rotation",0);
cv::imshow("before rotation",gaussian_mask_max_length);
*/
cv::warpAffine(gaussian_mask_max_length,gaussian_mask_rotated,affin_mat,dist_size);
return gaussian_mask_rotated;
}