SEXP updateFaceNormals(SEXP vb_, SEXP it_) {
try {
NumericMatrix vb(vb_);
IntegerMatrix it(it_);
mat vbA(vb.begin(),vb.nrow(),vb.ncol());
mat normals(it.nrow(), it.ncol()); normals.fill(0.0);
imat itA(it.begin(),it.nrow(),it.ncol());
int nit = it.ncol();
colvec tmp0(3), tmp1(3), ntmp(3);
for (int i=0; i < nit; ++i) {
tmp0 = vbA.col(itA(1,i))-vbA.col(itA(0,i));
tmp1 = vbA.col(itA(2,i))-vbA.col(itA(0,i));
crosspArma(tmp0,tmp1,ntmp);
double nlen = norm(ntmp,2);
if (nlen > 0)
ntmp /= nlen;
normals.col(i) = ntmp;
}
return Rcpp::wrap(normals);
} catch (std::exception& e) {
::Rf_error( e.what());
} catch (...) {
::Rf_error("unknown exception");
}
}
texture_2d tangent_flow_map(const texture_2d& src, float sigma) {
texture_2d tmp0(src.clone_format());
texture_2d tmp1(src.clone_format());
texture_2d dst(src.clone_format());
glsl_program sst("sst_fs.glsl");
sst.use();
sst.bind_sampler("img", src);
sst.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
sst.draw(&tmp0);
glsl_program gauss("gauss_fs.glsl");
gauss.use();
gauss.bind_sampler("img", tmp0);
gauss.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
gauss.set_uniform_1f("sigma", sigma);
gauss.draw(&tmp1);
glsl_program tfm("tfm_fs.glsl");
tfm.use();
tfm.bind_sampler("img", tmp1);
tfm.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
tfm.draw(&dst);
return dst;
}
SEXP updateVertexNormals(SEXP vb_, SEXP it_,SEXP angweight_) {
try {
typedef unsigned int uint;
bool angweight = Rcpp::as<bool>(angweight_);
NumericMatrix vb(vb_);
IntegerMatrix it(it_);
mat vbA(vb.begin(),vb.nrow(),vb.ncol());
mat normals = vbA*0;
imat itA(it.begin(),it.nrow(),it.ncol());
//setup vectors to store temporary data
colvec tmp0(3), tmp1(3), tmp2(3), angtmp(3), ntmp(3);
int nit = it.ncol();
for (int i=0; i < nit; ++i) {
tmp0 = vbA.col(itA(1,i))-vbA.col(itA(0,i));
tmp1 = vbA.col(itA(2,i))-vbA.col(itA(0,i));
if (angweight) {
tmp2 = vbA.col(itA(1,i))-vbA.col(itA(2,i));
angtmp(0) = angcalcArma(tmp0,tmp1);
angtmp(1) = angcalcArma(tmp0, tmp2);
angtmp(2) = angcalcArma(-tmp1, tmp2);
}
crosspArma(tmp0,tmp1,ntmp);
for (int j=0; j < 3; ++j) {
double co = dot(normals.col(itA(j,i)),ntmp);
if (co < 0) {
if (!angweight) {
normals.col(itA(j,i)) -= ntmp;
} else {
normals.col(itA(j,i)) -= ntmp*angtmp(j);
}
} else {
if (! angweight) {
normals.col(itA(j,i)) += ntmp;
} else {
normals.col(itA(j,i)) += ntmp*angtmp(j);
}
}
}
}
for (uint i=0; i < normals.n_cols; ++i) {
double nlen = norm(normals.col(i),2);
if (nlen > 0)
normals.col(i) /= nlen;
}
return Rcpp::wrap(normals);
} catch (std::exception& e) {
::Rf_error( e.what());
} catch (...) {
::Rf_error("unknown exception");
}
}
/* SRC: classes/exception.php line 142 */
String c_Exception::t___tostring() {
INSTANCE_METHOD_INJECTION_BUILTIN(Exception, Exception::__toString);
{
StringBuffer tmp0_buf;
tmp0_buf.appendWithTaint("exception '", 11);
tmp0_buf.appendWithTaint(toString(x_get_class(VarNR(GET_THIS_TYPED(Exception)))));
tmp0_buf.appendWithTaint("' with message '", 16);
tmp0_buf.appendWithTaint(toString(t_getmessage()));
tmp0_buf.appendWithTaint("' in ", 5);
tmp0_buf.appendWithTaint(toString(t_getfile()));
tmp0_buf.appendWithTaint(":", 1);
tmp0_buf.appendWithTaint(toString(t_getline()));
tmp0_buf.appendWithTaint("\nStack trace:\n", 14);
tmp0_buf.appendWithTaint(t_gettraceasstring());
CStrRef tmp0(tmp0_buf.detachWithTaint());
return tmp0;
}
}
void InitSLState(
const dTensorBC4& q, const dTensorBC4& aux, SL_state& sl_state )
{
void ComputeElecField(double t, const dTensor2& node1d,
const dTensorBC4& qvals, dTensorBC3& Evals);
void ConvertQ2dToQ1d(const int &mopt, int istart, int iend,
const dTensorBC4& qin, dTensorBC3& qout);
void IntegrateQ1dMoment1(const dTensorBC4& q2d, dTensorBC3& q1d);
const int space_order = dogParams.get_space_order();
const int mx = q.getsize(1);
const int my = q.getsize(2);
const int meqn = q.getsize(3);
const int maux = aux.getsize(2);
const int kmax = q.getsize(4);
const int mbc = q.getmbc();
const int mpoints = space_order*space_order;
const int kmax1d = space_order;
const double tn = sl_state.tn;
//////////////////////// Compute Electric Field E(t) ////////////////////
// save 1d grid points ( this is used for poisson solve )
dTensorBC3 Enow(mx, meqn, kmax1d, mbc, 1);
ComputeElecField( tn, *sl_state.node1d, *sl_state.qnew, Enow);
//////////// Necessary terms for Et = -M1 + g(x,t) /////////////////////
dTensorBC3 M1(mx, meqn, kmax1d,mbc,1);
IntegrateQ1dMoment1(q, M1); // first moment
//////////// Necessary terms for Ett = 2*KE_x - rho*E + g_t - psi_u ///////
dTensorBC3 KE(mx, meqn, kmax1d,mbc,1);
void IntegrateQ1dMoment2(const dTensorBC4& q2d, dTensorBC3& q1d);
IntegrateQ1dMoment2(q, KE); // 1/2 * \int v^2 * f dv //
SetBndValues1D( KE );
SetBndValues1D( Enow );
SetBndValues1D( M1 );
// do something to compute KE_x ... //
dTensorBC3 gradKE(mx,2,kmax1d,mbc,1);
FiniteDiff( 1, 2, KE, gradKE ); // compute KE_x and KE_xx //
dTensorBC3 rho(mx,meqn,kmax1d,mbc,1);
dTensorBC3 prod(mx,meqn,kmax1d,mbc,1);
void IntegrateQ1d(const int mopt, const dTensorBC4& q2d, dTensorBC3& q1d);
void MultiplyFunctions(const dTensorBC3& Q1, const dTensorBC3& Q2,
dTensorBC3& qnew);
IntegrateQ1d( 1, q, rho );
MultiplyFunctions( rho, Enow, prod );
/////////////////////// Save E, Et, Ett, //////////////////////////////////
for( int i = 1; i <= mx; i++ )
for( int k = 1; k <= kmax1d; k ++ )
{
double E = Enow.get ( i, 1, k );
double Et = -M1.get ( i, 1, k ); // + g(x,t)
double Ett = -prod.get(i,1,k) + 2.0*gradKE.get(i,1,k); // + others //
sl_state.aux1d->set(i,2,1, k, E );
sl_state.aux1d->set(i,2,2, k, Et );
sl_state.aux1d->set(i,2,3, k, Ett );
}
///////////////////////////////////////////////////////////////////////////
// terms used for 4th order stuff ... //
// Ettt = -M3_xx + (2*E_x+rho)*M1 + 3*E*(M1)_x
dTensorBC3 tmp0(mx,2*meqn,kmax1d,mbc,1);
dTensorBC3 tmp1(mx,meqn,kmax1d,mbc,1);
// compute the third moment and its 2nd derivative
dTensorBC3 M3 (mx,meqn,kmax1d,mbc,1);
dTensorBC3 M3_x (mx,2*meqn,kmax1d,mbc,1);
void IntegrateQ1dMoment3(const dTensorBC4& q2d, dTensorBC3& q1d);
IntegrateQ1dMoment3(q, M3 );
SetBndValues1D( M3 );
FiniteDiff( 1, 2, M3, M3_x );
// Compute 2*Ex+rho //
FiniteDiff(1, 2*meqn, Enow, tmp0);
for( int i=1; i <= mx; i++ )
for( int k=1; k <= kmax1d; k++ )
{ tmp1.set(i,1,k, 2.0*tmp0.get(i,1,k) + rho.get(i,1,k) ); }
// compute (2Ex+rho) * M1
dTensorBC3 prod1(mx,meqn,kmax1d,mbc,1);
MultiplyFunctions( tmp1, M1, prod1 );
// compute M1_x and M1_xx
dTensorBC3 M1_x (mx,2*meqn,kmax1d,mbc,1);
FiniteDiff( 1, 2, M1, M1_x );
//compute 3*M1_x and E * (3*M1)_x
dTensorBC3 prod2(mx,meqn,kmax1d,mbc,1);
for( int i=1; i <= mx; i++ )
for( int k=1; k <= kmax1d; k++ )
{ tmp1.set(i, 1, k, 3.0*M1_x.get(i, 1, k) ); }
MultiplyFunctions( Enow, tmp1, prod2 );
/////////////////////// Save Ettt /////////////////////////////////////////
for( int i = 1; i <= mx; i++ )
for( int k = 1; k <= kmax1d; k ++ )
{
double Ettt = -M3_x.get(i,2,k) + prod1.get(i,1,k) + prod2.get(i,1,k);
sl_state.aux1d->set(i,2,4, k, Ettt );
}
///////////////////////////////////////////////////////////////////////////
if ( dogParams.get_source_term()>0 )
{
double* t_ptr = new double;
*t_ptr = tn;
// 2D Electric field, and 1D Electric Field
dTensorBC4* ExactE;
ExactE = new dTensorBC4(mx,1,4,kmax,mbc);
dTensorBC3* ExactE1d;
ExactE1d = new dTensorBC3(mx,4,kmax1d,mbc,1);
// Extra Source terms needed for the electric field
dTensorBC4* ExtraE;
ExtraE = new dTensorBC4(mx,1,4,kmax,mbc);
dTensorBC3* ExtraE1d;
ExtraE1d = new dTensorBC3(mx,4,kmax1d,mbc,1);
// Exact, electric field: (TODO - REMOVE THIS!)
// void ElectricField(const dTensor2& xpts, dTensor2& e, void* data);
// L2Project_extra(1-mbc, mx+mbc, 1, 1, space_order, -1, ExactE,
// &ElectricField, (void*)t_ptr );
// ConvertQ2dToQ1d(1, 1, mx, *ExactE, *ExactE1d);
// Extra Source terms:
void ExtraSourceWrap(const dTensor2& xpts,
const dTensor2& NOT_USED_1,
const dTensor2& NOT_USED_2,
dTensor2& e,
void* data);
L2Project_extra(1, mx, 1, 1, 20, space_order,
space_order, space_order,
&q, &aux, ExtraE, &ExtraSourceWrap, (void*)t_ptr );
ConvertQ2dToQ1d(1, 1, mx, *ExtraE, *ExtraE1d);
for( int i=1; i <= mx; i++ )
for( int k=1; k <= kmax1d; k++ )
{
// electric fields w/o source term parts added in //
double Et = sl_state.aux1d->get(i,2,2,k);
double Ett = sl_state.aux1d->get(i,2,3,k);
double Ettt = sl_state.aux1d->get(i,2,4,k);
// add in missing terms from previously set values //
sl_state.aux1d->set(i,2,2, k, Et + ExtraE1d->get(i,2,k) );
sl_state.aux1d->set(i,2,3, k, Ett + ExtraE1d->get(i,3,k) );
sl_state.aux1d->set(i,2,4, k, Ettt + ExtraE1d->get(i,4,k) );
// sl_state.aux1d->set(i,2,1, k, 0. );
// sl_state.aux1d->set(i,2,2, k, 0. );
// sl_state.aux1d->set(i,2,3, k, 0. );
// sl_state.aux1d->set(i,2,4, k, 0. );
// ADD IN EXACT ELECTRIC FIELD HERE:
// sl_state.aux1d->set(i,2,1, k, ExactE1d->get(i,1,k) );
// sl_state.aux1d->set(i,2,2, k, ExactE1d->get(i,2,k) );
// sl_state.aux1d->set(i,2,3, k, ExactE1d->get(i,3,k) );
// sl_state.aux1d->set(i,2,4, k, ExactE1d->get(i,4,k) );
}
delete ExactE;
delete ExactE1d;
delete t_ptr;
delete ExtraE;
delete ExtraE1d;
}
}
/* SRC: classes/soapfault.php line 12 */
void c_SoapFault::t___construct(Variant v_code, Variant v_message, Variant v_actor // = null
, Variant v_detail // = null
, Variant v_name // = null
, Variant v_header // = null
) {
INSTANCE_METHOD_INJECTION_BUILTIN(SoapFault, SoapFault::__construct);
Variant v_fault_ns;
Variant v_fault_code;
int64 v_SOAP_1_1 = 0;
int64 v_SOAP_1_2 = 0;
String v_SOAP_1_1_ENV_NAMESPACE;
String v_SOAP_1_2_ENV_NAMESPACE;
int64 v_soap_version = 0;
ObjectData *obj_tmp UNUSED;
setNull(v_fault_ns);
setNull(v_fault_code);
if (x_is_string(v_code)) {
{
v_fault_code.assignVal(v_code);
}
}
else {
bool tmp0;
{
bool tmp1 = (x_is_array(v_code));
if (tmp1) {
int64 tmp2((x_count(v_code)));
tmp1 = (equal(tmp2, 2L));
}
tmp0 = (tmp1);
}
if (tmp0) {
{
{
const Variant &tmp0((x_array_values(v_code)));
v_code.assignVal(tmp0);
}
{
const Variant &tmp0((v_code.rvalAt(0L, AccessFlags::Error)));
v_fault_ns.assignVal(tmp0);
}
{
const Variant &tmp0((v_code.rvalAt(1L, AccessFlags::Error)));
v_fault_code.assignVal(tmp0);
}
if ((!(x_is_string(v_fault_ns)) || !(x_is_string(v_fault_code)))) {
{
x_hphp_throw_fatal_error(NAMSTR(s_sys_ss5db5b000, "Invalid fault code"));
return;
}
}
}
}
else {
{
x_hphp_throw_fatal_error(NAMSTR(s_sys_ss5db5b000, "Invalid fault code"));
return;
}
}
}
m_faultcodens.assignVal(v_fault_ns);
m_faultcode.assignVal(v_fault_code);
if (empty(m_faultcode)) {
{
x_hphp_throw_fatal_error(NAMSTR(s_sys_ss5db5b000, "Invalid fault code"));
return;
}
}
{
Variant tmp0((m_message.assignVal(v_message)));
m_faultstring.assignVal(tmp0);
}
m_faultactor.assignVal(v_actor);
m_detail.assignVal(v_detail);
m__name.assignVal(v_name);
m_headerfault.assignVal(v_header);
v_SOAP_1_1 = 1L;
v_SOAP_1_2 = 2L;
v_SOAP_1_1_ENV_NAMESPACE = NAMSTR(s_sys_ss0842226e, "http://schemas.xmlsoap.org/soap/envelope/");
v_SOAP_1_2_ENV_NAMESPACE = NAMSTR(s_sys_ss2cc85e9b, "http://www.w3.org/2003/05/soap-envelope");
{
int64 tmp0((x__soap_active_version()));
v_soap_version = tmp0;
}
if (empty(m_faultcodens)) {
{
if (equal(v_soap_version, v_SOAP_1_1)) {
{
if ((((equal(m_faultcode, NAMSTR(s_sys_ss129b7287, "Client")) || equal(m_faultcode, NAMSTR(s_sys_ss35d432f4, "Server"))) || equal(m_faultcode, NAMSTR(s_sys_ss4a69d66a, "VersionMismatch"))) || equal(m_faultcode, NAMSTR(s_sys_ss65decfcb, "MustUnderstand")))) {
{
m_faultcodens = v_SOAP_1_1_ENV_NAMESPACE;
}
}
}
}
else if (equal(v_soap_version, v_SOAP_1_2)) {
{
if (equal(m_faultcode, NAMSTR(s_sys_ss129b7287, "Client"))) {
{
m_faultcode = NAMSTR(s_sys_ss58532c4b, "Sender");
m_faultcodens = v_SOAP_1_2_ENV_NAMESPACE;
}
}
else if (equal(m_faultcode, NAMSTR(s_sys_ss35d432f4, "Server"))) {
{
m_faultcode = NAMSTR(s_sys_ss722b78d7, "Receiver");
m_faultcodens = v_SOAP_1_2_ENV_NAMESPACE;
}
}
else if (((equal(m_faultcode, NAMSTR(s_sys_ss4a69d66a, "VersionMismatch")) || equal(m_faultcode, NAMSTR(s_sys_ss65decfcb, "MustUnderstand"))) || equal(m_faultcode, NAMSTR(s_sys_ss6d34f1cc, "DataEncodingUnknown")))) {
{
m_faultcodens = v_SOAP_1_2_ENV_NAMESPACE;
}
}
}
}
}
}
}
VectorType solve(const MatrixType & matrix, VectorType const & rhs, bicgstab_tag const & tag)
{
typedef typename viennacl::result_of::value_type<VectorType>::type ScalarType;
typedef typename viennacl::result_of::cpu_value_type<ScalarType>::type CPU_ScalarType;
unsigned int problem_size = viennacl::traits::size(rhs);
VectorType result(problem_size);
viennacl::traits::clear(result);
VectorType residual = rhs;
VectorType p = rhs;
VectorType r0star = rhs;
VectorType tmp0(problem_size);
VectorType tmp1(problem_size);
VectorType s(problem_size);
CPU_ScalarType norm_rhs_host = viennacl::linalg::norm_2(residual);
CPU_ScalarType ip_rr0star = norm_rhs_host * norm_rhs_host;
CPU_ScalarType beta;
CPU_ScalarType alpha;
CPU_ScalarType omega;
//ScalarType inner_prod_temp; //temporary variable for inner product computation
CPU_ScalarType new_ip_rr0star = 0;
CPU_ScalarType residual_norm = norm_rhs_host;
if (norm_rhs_host == 0) //solution is zero if RHS norm is zero
return result;
bool restart_flag = true;
std::size_t last_restart = 0;
for (std::size_t i = 0; i < tag.max_iterations(); ++i)
{
if (restart_flag)
{
residual = rhs;
residual -= viennacl::linalg::prod(matrix, result);
p = residual;
r0star = residual;
ip_rr0star = viennacl::linalg::norm_2(residual);
ip_rr0star *= ip_rr0star;
restart_flag = false;
last_restart = i;
}
tag.iters(i+1);
tmp0 = viennacl::linalg::prod(matrix, p);
alpha = ip_rr0star / viennacl::linalg::inner_prod(tmp0, r0star);
s = residual - alpha*tmp0;
tmp1 = viennacl::linalg::prod(matrix, s);
CPU_ScalarType norm_tmp1 = viennacl::linalg::norm_2(tmp1);
omega = viennacl::linalg::inner_prod(tmp1, s) / (norm_tmp1 * norm_tmp1);
result += alpha * p + omega * s;
residual = s - omega * tmp1;
new_ip_rr0star = viennacl::linalg::inner_prod(residual, r0star);
residual_norm = viennacl::linalg::norm_2(residual);
if (std::fabs(residual_norm / norm_rhs_host) < tag.tolerance())
break;
beta = new_ip_rr0star / ip_rr0star * alpha/omega;
ip_rr0star = new_ip_rr0star;
if (ip_rr0star == 0 || omega == 0 || i - last_restart > tag.max_iterations_before_restart()) //search direction degenerate. A restart might help
restart_flag = true;
// Execution of
// p = residual + beta * (p - omega*tmp0);
// without introducing temporary vectors:
p -= omega * tmp0;
p = residual + beta * p;
}
//store last error estimate:
tag.error(residual_norm / norm_rhs_host);
return result;
}
