h256 hash256(u256Map const& _s)
{
// build patricia tree.
if (_s.empty())
return h256();
HexMap hexMap;
for (auto i = _s.rbegin(); i != _s.rend(); ++i)
hexMap[asNibbles(toBigEndianString(i->first))] = asString(rlp(i->second));
RLPStream s;
hash256rlp(hexMap, hexMap.cbegin(), hexMap.cend(), 0, s);
return sha3(s.out());
}
namespace dev
{
h256 const EmptyTrie = sha3(rlp(""));
/*
* Hex-prefix Notation. First nibble has flags: oddness = 2^0 & termination = 2^1
* NOTE: the "termination marker" and "leaf-node" specifier are completely equivalent.
* [0,0,1,2,3,4,5] 0x10012345
* [0,1,2,3,4,5] 0x00012345
* [1,2,3,4,5] 0x112345
* [0,0,1,2,3,4] 0x00001234
* [0,1,2,3,4] 0x101234
* [1,2,3,4] 0x001234
* [0,0,1,2,3,4,5,T] 0x30012345
* [0,0,1,2,3,4,T] 0x20001234
* [0,1,2,3,4,5,T] 0x20012345
* [1,2,3,4,5,T] 0x312345
* [1,2,3,4,T] 0x201234
*/
std::string hexPrefixEncode(bytes const& _hexVector, bool _leaf, int _begin, int _end)
{
unsigned begin = _begin;
unsigned end = _end < 0 ? _hexVector.size() + 1 + _end : _end;
bool odd = ((end - begin) % 2) != 0;
std::string ret(1, ((_leaf ? 2 : 0) | (odd ? 1 : 0)) * 16);
if (odd)
{
ret[0] |= _hexVector[begin];
++begin;
}
for (unsigned i = begin; i < end; i += 2)
ret += _hexVector[i] * 16 + _hexVector[i + 1];
return ret;
}
std::string hexPrefixEncode(bytesConstRef _data, bool _leaf, int _beginNibble, int _endNibble, unsigned _offset)
{
unsigned begin = _beginNibble + _offset;
unsigned end = (_endNibble < 0 ? ((int)(_data.size() * 2 - _offset) + 1) + _endNibble : _endNibble) + _offset;
bool odd = (end - begin) & 1;
std::string ret(1, ((_leaf ? 2 : 0) | (odd ? 1 : 0)) * 16);
ret.reserve((end - begin) / 2 + 1);
unsigned d = odd ? 1 : 2;
for (auto i = begin; i < end; ++i, ++d)
{
byte n = nibble(_data, i);
if (d & 1) // odd
ret.back() |= n; // or the nibble onto the back
else
ret.push_back(n << 4); // push the nibble on to the back << 4
}
return ret;
}
std::string hexPrefixEncode(bytesConstRef _d1, unsigned _o1, bytesConstRef _d2, unsigned _o2, bool _leaf)
{
unsigned begin1 = _o1;
unsigned end1 = _d1.size() * 2;
unsigned begin2 = _o2;
unsigned end2 = _d2.size() * 2;
bool odd = (end1 - begin1 + end2 - begin2) & 1;
std::string ret(1, ((_leaf ? 2 : 0) | (odd ? 1 : 0)) * 16);
ret.reserve((end1 - begin1 + end2 - begin2) / 2 + 1);
unsigned d = odd ? 1 : 2;
for (auto i = begin1; i < end1; ++i, ++d)
{
byte n = nibble(_d1, i);
if (d & 1) // odd
ret.back() |= n; // or the nibble onto the back
else
ret.push_back(n << 4); // push the nibble on to the back << 4
}
for (auto i = begin2; i < end2; ++i, ++d)
{
byte n = nibble(_d2, i);
if (d & 1) // odd
ret.back() |= n; // or the nibble onto the back
else
ret.push_back(n << 4); // push the nibble on to the back << 4
}
return ret;
}
byte uniqueInUse(RLP const& _orig, byte except)
{
byte used = 255;
for (unsigned i = 0; i < 17; ++i)
if (i != except && !_orig[i].isEmpty())
{
if (used == 255)
used = (byte)i;
else
return 255;
}
return used;
}
}
void doTransactionTests(json_spirit::mValue& _v, bool _fillin)
{
for (auto& i: _v.get_obj())
{
cerr << i.first << endl;
mObject& o = i.second.get_obj();
if (_fillin)
{
TBOOST_REQUIRE((o.count("transaction") > 0));
mObject tObj = o["transaction"].get_obj();
//Construct Rlp of the given transaction
RLPStream rlpStream = createRLPStreamFromTransactionFields(tObj);
o["rlp"] = toHex(rlpStream.out(), 2, HexPrefix::Add);
try
{
Transaction txFromFields(rlpStream.out(), CheckTransaction::Everything);
if (!txFromFields.signature().isValid())
BOOST_THROW_EXCEPTION(Exception() << errinfo_comment("transaction from RLP signature is invalid") );
o["sender"] = toString(txFromFields.sender());
o["transaction"] = ImportTest::makeAllFieldsHex(tObj);
}
catch(Exception const& _e)
{
//Transaction is InValid
cnote << "Transaction Exception: " << diagnostic_information(_e);
o.erase(o.find("transaction"));
if (o.count("expect") > 0)
{
bool expectInValid = (o["expect"].get_str() == "invalid");
if (Options::get().checkState)
{TBOOST_CHECK_MESSAGE(expectInValid, "Check state: Transaction '" << i.first << "' is expected to be valid!");}
else
{TBOOST_WARN_MESSAGE(expectInValid, "Check state: Transaction '" << i.first << "' is expected to be valid!");}
o.erase(o.find("expect"));
}
}
//Transaction is Valid
if (o.count("expect") > 0)
{
bool expectValid = (o["expect"].get_str() == "valid");
if (Options::get().checkState)
{TBOOST_CHECK_MESSAGE(expectValid, "Check state: Transaction '" << i.first << "' is expected to be invalid!");}
else
{TBOOST_WARN_MESSAGE(expectValid, "Check state: Transaction '" << i.first << "' is expected to be invalid!");}
o.erase(o.find("expect"));
}
}
else
{
TBOOST_REQUIRE((o.count("rlp") > 0));
Transaction txFromRlp;
try
{
bytes stream = importByteArray(o["rlp"].get_str());
RLP rlp(stream);
txFromRlp = Transaction(rlp.data(), CheckTransaction::Everything);
if (!txFromRlp.signature().isValid())
BOOST_THROW_EXCEPTION(Exception() << errinfo_comment("transaction from RLP signature is invalid") );
}
catch(Exception const& _e)
{
cnote << i.first;
cnote << "Transaction Exception: " << diagnostic_information(_e);
TBOOST_CHECK_MESSAGE((o.count("transaction") == 0), "A transaction object should not be defined because the RLP is invalid!");
continue;
}
catch(...)
{
TBOOST_CHECK_MESSAGE((o.count("transaction") == 0), "A transaction object should not be defined because the RLP is invalid!");
continue;
}
TBOOST_REQUIRE((o.count("transaction") > 0));
mObject tObj = o["transaction"].get_obj();
Transaction txFromFields(createRLPStreamFromTransactionFields(tObj).out(), CheckTransaction::Everything);
//Check the fields restored from RLP to original fields
TBOOST_CHECK_MESSAGE((txFromFields.data() == txFromRlp.data()), "Data in given RLP not matching the Transaction data!");
TBOOST_CHECK_MESSAGE((txFromFields.value() == txFromRlp.value()), "Value in given RLP not matching the Transaction value!");
TBOOST_CHECK_MESSAGE((txFromFields.gasPrice() == txFromRlp.gasPrice()), "GasPrice in given RLP not matching the Transaction gasPrice!");
TBOOST_CHECK_MESSAGE((txFromFields.gas() == txFromRlp.gas()),"Gas in given RLP not matching the Transaction gas!");
TBOOST_CHECK_MESSAGE((txFromFields.nonce() == txFromRlp.nonce()),"Nonce in given RLP not matching the Transaction nonce!");
TBOOST_CHECK_MESSAGE((txFromFields.receiveAddress() == txFromRlp.receiveAddress()), "Receive address in given RLP not matching the Transaction 'to' address!");
TBOOST_CHECK_MESSAGE((txFromFields.sender() == txFromRlp.sender()), "Transaction sender address in given RLP not matching the Transaction 'vrs' signature!");
TBOOST_CHECK_MESSAGE((txFromFields == txFromRlp), "However, txFromFields != txFromRlp!");
TBOOST_REQUIRE ((o.count("sender") > 0));
Address addressReaded = Address(o["sender"].get_str());
TBOOST_CHECK_MESSAGE((txFromFields.sender() == addressReaded || txFromRlp.sender() == addressReaded), "Signature address of sender does not match given sender address!");
}
}//for
}//doTransactionTests
namespace eth
{
const h256 c_shaNull = sha3(rlp(""));
}
int main(int argc, char **argv) {
int res = ERR_SUCCESS;
#ifdef WITH_PETSC
PetscInitialize(&argc, &argv, (char *) PETSC_NULL, PETSC_NULL);
#endif
set_verbose(false);
if (argc < 5) error("Not enough parameters.");
H1ShapesetLobattoHex shapeset;
printf("* Loading mesh '%s'\n", argv[1]);
Mesh mesh;
Mesh3DReader mloader;
if (!mloader.load(argv[1], &mesh)) error("Loading mesh file '%s'\n", argv[1]);
printf("* Setting the space up\n");
H1Space space(&mesh, &shapeset);
space.set_bc_types(bc_types);
space.set_essential_bc_values(essential_bc_values);
int o[3] = { 0, 0, 0 };
sscanf(argv[2], "%d", o + 0);
sscanf(argv[3], "%d", o + 1);
sscanf(argv[4], "%d", o + 2);
order3_t order(o[0], o[1], o[2]);
printf(" - Setting uniform order to (%d, %d, %d)\n", order.x, order.y, order.z);
space.set_uniform_order(order);
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<ord_t, ord_t>, SYM, ANY);
wf.add_vector_form(linear_form<double, scalar>, linear_form<ord_t, ord_t>, ANY);
LinearProblem lp(&wf);
lp.set_space(&space);
bool done = false;
int iter = 0;
do {
Timer assemble_timer("Assembling stiffness matrix");
Timer solve_timer("Solving stiffness matrix");
printf("\n=== Iter #%d ================================================================\n", iter);
printf("\nSolution\n");
#if defined WITH_UMFPACK
UMFPackMatrix mat;
UMFPackVector rhs;
UMFPackLinearSolver solver(&mat, &rhs);
#elif defined WITH_PARDISO
PardisoMatrix mat;
PardisoVector rhs;
PardisoLinearSolver solver(&mat, &rhs);
#elif defined WITH_PETSC
PetscMatrix mat;
PetscVector rhs;
PetscLinearSolver solver(&mat, &rhs);
#elif defined WITH_MUMPS
MumpsMatrix mat;
MumpsVector rhs;
MumpsSolver solver(&mat, &rhs);
#endif
int ndofs = space.assign_dofs();
printf(" - Number of DOFs: %d\n", ndofs);
// assemble stiffness matrix
printf(" - Assembling... "); fflush(stdout);
assemble_timer.reset();
assemble_timer.start();
lp.assemble(&mat, &rhs);
assemble_timer.stop();
printf("done in %s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds());
// solve the stiffness matrix
printf(" - Solving... "); fflush(stdout);
solve_timer.reset();
solve_timer.start();
bool solved = solver.solve();
solve_timer.stop();
if (solved)
printf("done in %s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds());
else {
res = ERR_FAILURE;
printf("failed\n");
break;
}
printf("Reference solution\n");
#if defined WITH_UMFPACK
UMFPackLinearSolver rsolver(&mat, &rhs);
#elif defined WITH_PARDISO
PardisoLinearSolver rsolver(&mat, &rhs);
#elif defined WITH_PETSC
PetscLinearSolver rsolver(&mat, &rhs);
#elif defined WITH_MUMPS
MumpsSolver rsolver(&mat, &rhs);
#endif
Mesh rmesh;
rmesh.copy(mesh);
rmesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ);
Space *rspace = space.dup(&rmesh);
rspace->copy_orders(space, 1);
LinearProblem rlp(&wf);
rlp.set_space(rspace);
int rndofs = rspace->assign_dofs();
printf(" - Number of DOFs: %d\n", rndofs);
printf(" - Assembling... "); fflush(stdout);
assemble_timer.reset();
assemble_timer.start();
rlp.assemble(&mat, &rhs);
assemble_timer.stop();
printf("done in %s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds());
printf(" - Solving... "); fflush(stdout);
solve_timer.reset();
solve_timer.start();
bool rsolved = rsolver.solve();
solve_timer.stop();
if (rsolved)
printf("done in %s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds());
else {
res = ERR_FAILURE;
printf("failed\n");
break;
}
Solution sln(&mesh);
sln.set_coeff_vector(&space, solver.get_solution());
Solution rsln(&rmesh);
rsln.set_coeff_vector(rspace, rsolver.get_solution());
printf("Adaptivity:\n");
H1Adapt hp(&space);
double tol = hp.calc_error(&sln, &rsln) * 100;
printf(" - tolerance: "); fflush(stdout);
printf("% lf\n", tol);
if (tol < TOLERANCE) {
printf("\nDone\n");
ExactSolution ex_sln(&mesh, exact_solution);
// norm
double h1_sln_norm = h1_norm(&sln);
double h1_err_norm = h1_error(&sln, &ex_sln);
printf(" - H1 solution norm: % le\n", h1_sln_norm);
printf(" - H1 error norm: % le\n", h1_err_norm);
double l2_sln_norm = l2_norm(&sln);
double l2_err_norm = l2_error(&sln, &ex_sln);
printf(" - L2 solution norm: % le\n", l2_sln_norm);
printf(" - L2 error norm: % le\n", l2_err_norm);
if (h1_err_norm > EPS || l2_err_norm > EPS) {
// calculated solution is not enough precise
res = ERR_FAILURE;
}
break;
}
Timer t("");
printf(" - adapting... "); fflush(stdout);
t.start();
hp.adapt(THRESHOLD);
t.stop();
printf("done in %lf secs (refined %d element(s))\n", t.get_seconds(), hp.get_num_refined_elements());
iter++;
} while (!done);
#ifdef WITH_PETSC
PetscFinalize();
#endif
return res;
}
/***********************************************************************************
* main program *
************************************************************************************/
int main(int argc, char **args)
{
#ifdef WITH_PETSC
PetscInitialize(NULL, NULL, PETSC_NULL, PETSC_NULL);
PetscPushErrorHandler(PetscIgnoreErrorHandler, PETSC_NULL); // Disable PETSc error handler.
#endif
// Load the inital mesh.
Mesh mesh;
Mesh3DReader mesh_loader;
mesh_loader.load("hexahedron.mesh3d", &mesh);
// Initial uniform mesh refinements.
printf("Performing %d initial mesh refinements.\n", INIT_REF_NUM);
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ);
Word_t (nelem) = mesh.get_num_elements();
printf("New number of elements is %d.\n", nelem);
//Initialize the shapeset and the cache.
H1ShapesetLobattoHex shapeset;
//Matrix solver.
#if defined WITH_UMFPACK
UMFPackMatrix mat;
UMFPackVector rhs;
UMFPackLinearSolver solver(&mat, &rhs);
#elif defined WITH_PETSC
PetscMatrix mat;
PetscVector rhs;
PetscLinearSolver solver(&mat, &rhs);
#elif defined WITH_MUMPS
MumpsMatrix mat;
MumpsVector rhs;
MumpsSolver solver(&mat, &rhs);
#endif
// Graphs of DOF convergence.
GnuplotGraph graph;
graph.set_captions("", "Degrees of Freedom", "Error [%]");
graph.set_log_y();
graph.add_row("Total error", "k", "-", "O");
// Create H1 space to setup the problem.
H1Space space(&mesh, &shapeset);
space.set_bc_types(bc_types);
space.set_essential_bc_values(essential_bc_values);
space.set_uniform_order(order3_t(P_INIT, P_INIT, P_INIT));
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(biform<double, double>, biform<ord_t, ord_t>, SYM, ANY);
wf.add_vector_form(liform<double, double>, liform<ord_t, ord_t>, ANY);
// Initialize the coarse mesh problem.
LinProblem lp(&wf);
lp.set_space(&space);
// Adaptivity loop.
int as = 0;
bool done = false;
do {
printf("\n---- Adaptivity step %d:\n", as);
printf("\nSolving on coarse mesh:\n");
// Procedures for coarse mesh problem.
// Assign DOF.
int ndof = space.assign_dofs();
printf(" - Number of DOF: %d\n", ndof);
// Assemble stiffness matrix and rhs.
printf(" - Assembling... ");
fflush(stdout);
if (lp.assemble(&mat, &rhs))
printf("done in %lf secs.\n", lp.get_time());
else
error("failed!");
// Solve the system.
printf(" - Solving... ");
fflush(stdout);
bool solved = solver.solve();
if (solved)
printf("done in %lf secs.\n", solver.get_time());
else
{
printf("Failed.\n");
break;
}
// Construct a solution.
Solution sln(&mesh);
sln.set_fe_solution(&space, solver.get_solution());
// Output the orders and the solution.
if (do_output)
{
out_orders(&space, "order", as);
out_fn(&sln, "sln", as);
}
// Solving fine mesh problem.
printf("Solving on fine mesh:\n");
// Matrix solver.
#if defined WITH_UMFPACK
UMFPackLinearSolver rsolver(&mat, &rhs);
#elif defined WITH_PETSC
PetscLinearSolver rsolver(&mat, &rhs);
#elif defined WITH_MUMPS
MumpsSolver rsolver(&mat, &rhs);
#endif
// Construct the refined mesh for reference(refined) solution.
Mesh rmesh;
rmesh.copy(mesh);
rmesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ);
// Setup space for the reference (globally refined) solution.
Space *rspace = space.dup(&rmesh);
rspace->copy_orders(space, 1);
// Initialize the mesh problem for reference solution.
LinProblem rlp(&wf);
rlp.set_space(rspace);
// Assign DOF.
int rndof = rspace->assign_dofs();
printf(" - Number of DOF: %d\n", rndof);
// Assemble stiffness matric and rhs.
printf(" - Assembling... ");
fflush(stdout);
if (rlp.assemble(&mat, &rhs))
printf("done in %lf secs.\n", rlp.get_time());
else
error("failed!");
// Solve the system.
printf(" - Solving... ");
fflush(stdout);
bool rsolved = rsolver.solve();
if (rsolved)
printf("done in %lf secs.\n", rsolver.get_time());
else
{
printf("failed.\n");
break;
}
// Construct the reference(refined) solution.
Solution rsln(&rmesh);
rsln.set_fe_solution(rspace, rsolver.get_solution());
// Compare coarse and fine mesh.
// Calculate the error estimate wrt. refined mesh solution.
double err = h1_error(&sln, &rsln);
printf(" - H1 error: % lf\n", err * 100);
// Save it to the graph.
graph.add_value(0, ndof, err * 100);
if (do_output)
graph.save("conv.gp");
// Calculate error estimates for adaptivity.
printf("Adaptivity\n");
printf(" - calculating error: ");
fflush(stdout);
H1Adapt hp(&space);
double err_est = hp.calc_error(&sln, &rsln) * 100;
printf("% lf %%\n", err_est);
// If error is too large, adapt the mesh.
if (err_est < ERR_STOP)
{
printf("\nDone\n");
break;
}
printf(" - adapting... ");
fflush(stdout);
hp.adapt(THRESHOLD);
printf("done in %lf secs (refined %d element(s)).\n", hp.get_adapt_time(), hp.get_num_refined_elements());
if (rndof >= NDOF_STOP)
{
printf("\nDone.\n");
break;
}
// Clean up.
delete rspace;
// Next adaptivity step.
as++;
mat.free();
rhs.free();
} while (!done);
#ifdef WITH_PETSC
PetscFinalize();
#endif
return 1;
}
