void pri_queue_test_less(void)
{
for (int i = 1; i != test_size; ++i)
{
pri_queue q, r;
test_data data = make_test_data(i);
test_data r_data(data);
r_data.pop_back();
fill_q(q, data);
fill_q(r, r_data);
BOOST_REQUIRE(r < q);
}
for (int i = 1; i != test_size; ++i)
{
pri_queue q, r;
test_data data = make_test_data(i);
test_data r_data(data);
data.push_back(data.back() + 1);
fill_q(q, data);
fill_q(r, r_data);
BOOST_REQUIRE(r < q);
}
for (int i = 1; i != test_size; ++i)
{
pri_queue q, r;
test_data data = make_test_data(i);
test_data r_data(data);
data.back() += 1;
fill_q(q, data);
fill_q(r, r_data);
BOOST_REQUIRE(r < q);
}
for (int i = 1; i != test_size; ++i)
{
pri_queue q, r;
test_data data = make_test_data(i);
test_data r_data(data);
r_data.front() -= 1;
fill_q(q, data);
fill_q(r, r_data);
BOOST_REQUIRE(r < q);
}
}
void FieldNewCalcLagDlg::Apply()
{
if (m_result->GetSelection() == wxNOT_FOUND) {
wxString msg("Please select a Result field.");
wxMessageDialog dlg (this, msg, "Error", wxOK | wxICON_ERROR);
dlg.ShowModal();
return;
}
if (m_weight->GetSelection() == wxNOT_FOUND) {
wxString msg("Please specify a Weights matrix.");
wxMessageDialog dlg (this, msg, "Error", wxOK | wxICON_ERROR);
dlg.ShowModal();
return;
}
if (m_var->GetSelection() == wxNOT_FOUND) {
wxString msg("Please select an Variable field.");
wxMessageDialog dlg (this, msg, "Error", wxOK | wxICON_ERROR);
dlg.ShowModal();
return;
}
int result_col = col_id_map[m_result->GetSelection()];
int var_col = col_id_map[m_var->GetSelection()];
TableState* ts = project->GetTableState();
wxString grp_nm = table_int->GetColName(result_col);
if (!GenUtils::CanModifyGrpAndShowMsgIfNot(ts, grp_nm)) return;
if (is_space_time &&
!IsAllTime(result_col, m_result_tm->GetSelection()) &&
IsAllTime(var_col, m_var_tm->GetSelection())) {
wxString msg("When \"all times\" selected for variable, result "
"field must also be \"all times.\"");
wxMessageDialog dlg (this, msg, "Error", wxOK | wxICON_ERROR);
dlg.ShowModal();
return;
}
std::vector<int> time_list;
if (IsAllTime(result_col, m_result_tm->GetSelection())) {
int ts = project->GetTableInt()->GetTimeSteps();
time_list.resize(ts);
for (int i=0; i<ts; i++) time_list[i] = i;
} else {
int tm = IsTimeVariant(result_col) ? m_result_tm->GetSelection() : 0;
time_list.resize(1);
time_list[0] = tm;
}
std::vector<double> data(table_int->GetNumberRows(), 0);
std::vector<bool> undefined(table_int->GetNumberRows(), false);
if (!IsAllTime(var_col, m_var_tm->GetSelection())) {
int tm = IsTimeVariant(var_col) ? m_var_tm->GetSelection() : 0;
table_int->GetColData(var_col, tm, data);
table_int->GetColUndefined(var_col, tm, undefined);
}
int rows = table_int->GetNumberRows();
std::vector<double> r_data(table_int->GetNumberRows(), 0);
std::vector<bool> r_undefined(table_int->GetNumberRows(), false);
GalWeight* gal_w = w_manager->GetGalWeight(m_weight->GetSelection());
if (gal_w == NULL) return;
GalElement* W = gal_w->gal;
for (int t=0; t<time_list.size(); t++) {
for (int i=0; i<rows; i++) {
r_data[i] = 0;
r_undefined[i] = false;
}
if (IsAllTime(var_col, m_var_tm->GetSelection())) {
table_int->GetColData(var_col, time_list[t], data);
table_int->GetColUndefined(var_col, time_list[t], undefined);
}
// Row-standardized lag calculation.
for (int i=0, iend=table_int->GetNumberRows(); i<iend; i++) {
double lag = 0;
if (W[i].size == 0) r_undefined[i] = true;
for (int j=0; j<W[i].size && !r_undefined[i]; j++) {
if (undefined[W[i].data[j]]) {
r_undefined[i] = true;
} else {
lag += data[W[i].data[j]];
}
}
r_data[i] = r_undefined[i] ? 0 : lag /= W[i].size;
}
table_int->SetColData(result_col, time_list[t], r_data);
table_int->SetColUndefined(result_col, time_list[t], r_undefined);
}
}
void FieldNewCalcUniDlg::Apply()
{
if (m_result->GetSelection() == wxNOT_FOUND) {
wxString msg("Please choose a Result field.");
wxMessageDialog dlg (this, msg, "Error", wxOK | wxICON_ERROR);
dlg.ShowModal();
return;
}
int result_col = col_id_map[m_result->GetSelection()];
int var_col = wxNOT_FOUND;
if (m_var_sel != wxNOT_FOUND) {
var_col = col_id_map[m_var_sel];
}
if (var_col == wxNOT_FOUND && !m_valid_const) {
wxString msg("Operation requires a valid field name or constant.");
wxMessageDialog dlg (this, msg, "Error", wxOK | wxICON_ERROR);
dlg.ShowModal();
return;
}
if (is_space_time && var_col != wxNOT_FOUND &&
!IsAllTime(result_col, m_result_tm->GetSelection()) &&
IsAllTime(var_col, m_var_tm->GetSelection())) {
wxString msg("When \"all times\" selected for variable, result "
"field must also be \"all times.\"");
wxMessageDialog dlg (this, msg, "Error", wxOK | wxICON_ERROR);
dlg.ShowModal();
return;
}
TableState* ts = project->GetTableState();
wxString grp_nm = table_int->GetColName(result_col);
if (!GenUtils::CanModifyGrpAndShowMsgIfNot(ts, grp_nm)) return;
// Mersenne Twister random number generator, randomly seeded
// with current time in seconds since Jan 1 1970.
static boost::mt19937 rng(std::time(0));
std::vector<int> time_list;
if (IsAllTime(result_col, m_result_tm->GetSelection())) {
int ts = project->GetTableInt()->GetTimeSteps();
time_list.resize(ts);
for (int i=0; i<ts; i++) time_list[i] = i;
} else {
int tm = IsTimeVariant(result_col) ? m_result_tm->GetSelection() : 0;
time_list.resize(1);
time_list[0] = tm;
}
int rows = table_int->GetNumberRows();
std::vector<double> data(rows, 0);
std::vector<bool> undefined(rows, false);
if (var_col != wxNOT_FOUND &&
!IsAllTime(var_col, m_var_tm->GetSelection())) {
int tm = IsTimeVariant(var_col) ? m_var_tm->GetSelection() : 0;
table_int->GetColData(var_col,tm, data);
table_int->GetColUndefined(var_col, tm, undefined);
} else {
for (int i=0; i<rows; i++) data[i] = m_const;
}
std::vector<double> r_data(table_int->GetNumberRows(), 0);
std::vector<bool> r_undefined(table_int->GetNumberRows(), false);
for (int t=0; t<time_list.size(); t++) {
if (var_col != wxNOT_FOUND &&
IsAllTime(var_col, m_var_tm->GetSelection()))
{
table_int->GetColData(var_col, time_list[t], data);
table_int->GetColUndefined(var_col, time_list[t], undefined);
}
for (int i=0; i<rows; i++) {
r_data[i] = data[i];
r_undefined[i] = undefined[i];
}
switch (m_op->GetSelection()) {
case assign_op:
{
}
break;
case negate_op:
{
for (int i=0; i<rows; i++) {
if (!undefined[i]) r_data[i] = -data[i];
}
}
break;
case invert_op:
{
for (int i=0; i<rows; i++) {
if (!undefined[i] && data[i] != 0) {
r_data[i] = 1.0 / data[i];
} else {
r_data[i] = 0;
r_undefined[i] = true;
}
}
}
break;
case sqrt_op:
{
for (int i=0; i<rows; i++) {
if (!undefined[i] && data[i] >= 0) {
r_data[i] = sqrt(data[i]);
} else {
r_data[i] = 0;
r_undefined[i] = true;
}
}
}
break;
case log_10_op:
{
for (int i=0; i<rows; i++) {
if (!undefined[i] && data[i] > 0) {
r_data[i] = log10(data[i]);
} else {
r_data[i] = 0;
r_undefined[i] = true;
}
}
}
break;
case log_e_op:
{
for (int i=0; i<rows; i++) {
if (!undefined[i] && data[i] > 0) {
r_data[i] = log(data[i]);
} else {
r_data[i] = 0;
r_undefined[i] = true;
}
}
}
break;
case dev_from_mean_op:
{
for (int i=0; i<rows; i++) {
if (undefined[i]) {
wxString msg;
msg << "Observation " << i;
msg << " is undefined. ";
msg << "Operation aborted.";
wxMessageDialog dlg (this, msg, "Error",
wxOK | wxICON_ERROR);
dlg.ShowModal();
return;
}
r_data[i] = data[i];
}
GenUtils::DeviationFromMean(r_data);
}
break;
case standardize_op:
{
for (int i=0; i<rows; i++) {
if (undefined[i]) {
wxString msg;
msg << "Observation ";
msg << i << " is undefined. ";
msg << "Operation aborted.";
wxMessageDialog dlg (this, msg, "Error",
wxOK | wxICON_ERROR);
dlg.ShowModal();
return;
}
r_data[i] = data[i];
}
double ssum = 0.0;
for (int i=0; i<rows; i++) ssum += r_data[i] * r_data[i];
if (ssum == 0) {
wxString msg("Standard deviation is 0, operation aborted.");
wxMessageDialog dlg (this, msg, "Error", wxOK|wxICON_ERROR);
dlg.ShowModal();
return;
}
GenUtils::StandardizeData(r_data);
}
break;
case shuffle_op:
{
for (int i=0; i<rows; i++) {
r_data[i] = data[i];
r_undefined[i] = undefined[i];
}
static boost::random::uniform_int_distribution<> X(0, rows-1);
// X(rng) -> returns a uniform random number from 0 to rows-1;
for (int i=0; i<rows; i++) {
// swap each item in data with a random position in data.
// This will produce a random permutation
int r = X(rng);
double d_t = r_data[r];
bool u_t = r_undefined[r];
r_data[r] = r_data[i];
r_undefined[r] = r_undefined[i];
r_data[i] = d_t;
r_undefined[i] = u_t;
if (undefined[i]) r_data[i] = 0;
if (undefined[r]) r_data[r] = 0;
}
}
break;
default:
return;
break;
}
table_int->SetColData(result_col, time_list[t], r_data);
table_int->SetColUndefined(result_col, time_list[t], r_undefined);
}
}
int CVODEModel::CVSpgmrPrecondSolve(
double t,
SundialsAbstractVector* y,
SundialsAbstractVector* fy,
SundialsAbstractVector* r,
SundialsAbstractVector* z,
double gamma,
double delta,
int lr,
SundialsAbstractVector* vtemp)
{
NULL_USE(y);
NULL_USE(fy);
NULL_USE(vtemp);
#ifndef USE_FAC_PRECONDITIONER
NULL_USE(gamma);
#endif
NULL_USE(delta);
NULL_USE(lr);
#ifdef USE_FAC_PRECONDITIONER
/*
* Convert passed-in CVODE vectors into SAMRAI vectors
*/
std::shared_ptr<SAMRAIVectorReal<double> > r_samvect(
Sundials_SAMRAIVector::getSAMRAIVector(r));
std::shared_ptr<SAMRAIVectorReal<double> > z_samvect(
Sundials_SAMRAIVector::getSAMRAIVector(z));
int ret_val = 0;
std::shared_ptr<PatchHierarchy> hierarchy(
r_samvect->getPatchHierarchy());
int r_indx = r_samvect->getComponentDescriptorIndex(0);
int z_indx = z_samvect->getComponentDescriptorIndex(0);
/******************************************************************
*
* We need to supply to the FAC solver a "version" of the z vector
* that contains ghost cells. The operations below allocate
* on the patches a scratch context of the solution vector z and
* fill it with z vector data
*
*****************************************************************/
/*
* Construct a communication schedule which will fill ghosts of
* soln_scratch with z vector data (z -> soln_scratch).
*/
RefineAlgorithm fill_z_vector_bounds;
std::shared_ptr<RefineOperator> refine_op(d_grid_geometry->
lookupRefineOperator(d_soln_var,
"CONSERVATIVE_LINEAR_REFINE"));
fill_z_vector_bounds.registerRefine(d_soln_scr_id,
z_indx,
d_soln_scr_id,
refine_op);
/*
* Set initial guess for z (if applicable) and copy z data into the
* solution scratch context.
*/
int ln;
for (ln = hierarchy->getFinestLevelNumber(); ln >= 0; --ln) {
std::shared_ptr<PatchLevel> level(hierarchy->getPatchLevel(ln));
if (!level->checkAllocated(d_soln_scr_id)) {
level->allocatePatchData(d_soln_scr_id);
}
for (PatchLevel::iterator p(level->begin()); p != level->end(); ++p) {
const std::shared_ptr<Patch>& patch = *p;
std::shared_ptr<CellData<double> > z_data(
SAMRAI_SHARED_PTR_CAST<CellData<double>, PatchData>(
patch->getPatchData(z_indx)));
TBOX_ASSERT(z_data);
/*
* Set initial guess for z here.
*/
z_data->fillAll(0.);
/*
* Scale RHS by 1/gamma
*/
PatchCellDataOpsReal<double> math_ops;
std::shared_ptr<CellData<double> > r_data(
SAMRAI_SHARED_PTR_CAST<CellData<double>, PatchData>(
patch->getPatchData(r_indx)));
TBOX_ASSERT(r_data);
math_ops.scale(r_data, 1.0 / gamma, r_data, r_data->getBox());
/*
* Copy interior data from z vector to soln_scratch
*/
std::shared_ptr<CellData<double> > z_scr_data(
SAMRAI_SHARED_PTR_CAST<CellData<double>, PatchData>(
patch->getPatchData(d_soln_scr_id)));
TBOX_ASSERT(z_scr_data);
z_scr_data->copy(*z_data);
}
/*
* Fill ghost boundaries of soln_scratch.
* Construct a schedule for each level, from the algorithm
* constructed above.
*/
std::shared_ptr<RefineSchedule> fill_z_vector_bounds_sched(
fill_z_vector_bounds.createSchedule(level,
ln - 1,
hierarchy,
this));
fill_z_vector_bounds_sched->fillData(t);
}
/******************************************************************
*
* Apply the FAC solver. It solves the system Az=r with the
* format "solveSystem(z, r)". A was constructed in the precondSetup()
* method.
*
******************************************************************/
if (d_print_solver_info) {
pout << "\t\tBefore FAC Solve (Az=r): "
<< "\n \t\t\tz_l2norm = " << z_samvect->L2Norm()
<< "\n \t\t\tz_maxnorm = " << z_samvect->maxNorm()
<< "\n \t\t\tr_l2norm = " << r_samvect->L2Norm()
<< "\n \t\t\tr_maxnorm = " << r_samvect->maxNorm()
<< endl;
}
/*
* Set paramemters in the FAC solver. It solves the system Az=r.
* Here we supply the max norm of r in order to scale the
* residual (i.e. residual = Az - r) to properly scale the convergence
* error.
*/
const int coarsest_solve_ln = 0;
const int finest_solve_ln = 0;
/*
* Note: I don't know why we are only solving on level 0 here.
* When upgrading to the new FAC solver from the old, I noticed
* that the old solver only solved on level 0. BTNG.
*/
bool converge = d_FAC_solver->solveSystem(d_soln_scr_id,
r_indx,
hierarchy,
coarsest_solve_ln,
finest_solve_ln);
if (d_print_solver_info) {
double avg_convergence, final_convergence;
d_FAC_solver->getConvergenceFactors(avg_convergence, final_convergence);
pout << " \t\t\tFinal Residual Norm: "
<< d_FAC_solver->getResidualNorm() << endl;
pout << " \t\t\tFinal Convergence Error: "
<< final_convergence << endl;
pout << " \t\t\tFinal Convergence Rate: "
<< avg_convergence << endl;
}
/******************************************************************
*
* The FAC solver has computed a solution to z but it is stored
* in the soln_scratch data space. Copy it from soln_scratch back
* into the z vector.
*
******************************************************************/
for (ln = hierarchy->getFinestLevelNumber(); ln >= 0; --ln) {
std::shared_ptr<PatchLevel> level(hierarchy->getPatchLevel(ln));
for (PatchLevel::iterator p(level->begin()); p != level->end(); ++p) {
const std::shared_ptr<Patch>& patch = *p;
std::shared_ptr<CellData<double> > soln_scratch(
SAMRAI_SHARED_PTR_CAST<CellData<double>, PatchData>(
patch->getPatchData(d_soln_scr_id)));
std::shared_ptr<CellData<double> > z(
SAMRAI_SHARED_PTR_CAST<CellData<double>, PatchData>(
patch->getPatchData(z_indx)));
TBOX_ASSERT(soln_scratch);
TBOX_ASSERT(z);
z->copy(*soln_scratch);
}
}
if (d_print_solver_info) {
double avg_convergence, final_convergence;
d_FAC_solver->getConvergenceFactors(avg_convergence, final_convergence);
pout << "\t\tAfter FAC Solve (Az=r): "
<< "\n \t\t\tz_l2norm = " << z_samvect->L2Norm()
<< "\n \t\t\tz_maxnorm = " << z_samvect->maxNorm()
<< "\n \t\t\tResidual Norm: " << d_FAC_solver->getResidualNorm()
<< "\n \t\t\tConvergence Error: " << final_convergence
<< endl;
}
if (converge != true) {
ret_val = 1;
}
/*
* Increment counter for number of precond solves
*/
++d_number_precond_solve;
return ret_val;
#else
return 0;
#endif
}
