void Skel_OPB_Comp::calc_buf(INT ** output,U_INT1 *** input)
{
if (first_line_in_pack())
{
for (INT d =0; d < dim_in() ; d++)
{
U_INT1 ** l = input[d];
for (int y = y0Buf() ; y < y1Buf() ; y++)
convert
(
_im_init[y-y0Buf()],
l[y]+x0Buf(),
x1Buf()-x0Buf()
);
Skeleton
(
_skel[d],
_im_init,
_sz.x,
_sz.y,
_larg
);
}
}
for (INT d =0; d < dim_in() ; d++)
convert
(
output[d]+x0(),
_skel[d][y_in_pack()-dy0()]-dx0(),
tx()
);
if (_AvecDist)
convert
(
output[1]+x0(),
_im_init[y_in_pack()-dy0()]-dx0(),
tx()
);
}
pointField quadrilateralDistribution::evaluate()
{
// Read needed material
label N0( readLabel(pointDict_.lookup("N0")) );
label N1( readLabel(pointDict_.lookup("N1")) );
point xs0( pointDict_.lookup("linestart0") );
point xe0( pointDict_.lookup("lineend0") );
point xe1( pointDict_.lookup("lineend1") );
scalar stretch0( pointDict_.lookupOrDefault<scalar>("stretch0", 1.0) );
scalar stretch1( pointDict_.lookupOrDefault<scalar>("stretch1", 1.0) );
// Define the return field
pointField res(N0*N1, xs0);
// Compute the scaling factor
scalar factor0(0.0);
scalar factor1(0.0);
for (int i=1; i < N0; i++)
{
factor0 += Foam::pow( stretch0, static_cast<scalar>(i) );
}
for (int i=1; i < N1; i++)
{
factor1 += Foam::pow( stretch1, static_cast<scalar>(i) );
}
point dx0( (xe0 - xs0)/factor0 );
point dx1( (xe1 - xs0)/factor1 );
// Compute points
for (int j=0; j < N1; j++)
{
if (j != 0)
{
res[j*N0] = res[(j - 1)*N0]
+ Foam::pow( stretch1, static_cast<scalar>(j))*dx1;
}
for (int i=1; i < N0; i++)
{
res[i + j*N0] = res[i - 1 + j*N0]
+ Foam::pow( stretch0, static_cast<scalar>(i) )*dx0;
}
}
return res;
}
scalar liform_surf(int n, double *wt, Func<scalar> *u_ext[], Func<double> *v, Geom<double> *e, ExtData<scalar> *ext)
{
cplx ii = cplx(0.0, 1.0);
scalar result = 0;
for (int i = 0; i < n; i++) {
scalar3 dx0(0, 0, 0), dy0(0, 0, 0), dz0(0, 0, 0);
scalar3 ev0(0.0, 0.0, 0.0);
ev0 = exact(e->x[i], e->y[i], e->z[i], dx0, dy0, dz0);
scalar curl_e[3];
scalar dx[3], dy[3], dz[3];
dx[0] = dx0[0]; dx[1] = dx0[1]; dx[2] = dx0[2];
dy[0] = dy0[0]; dy[1] = dy0[1]; dy[2] = dy0[2];
dz[0] = dz0[0]; dz[1] = dz0[1]; dz[2] = dz0[2];
calc_curl(dx, dy, dz, curl_e);
scalar tpe[3];
scalar ev[3];
ev[0] = ev0[0]; ev[1] = ev0[1]; ev[2] = ev0[2];
calc_tan_proj(e->nx[i], e->ny[i], e->nz[i], ev, tpe);
scalar g[3] = {
(e->nz[i] * curl_e[1] - e->ny[i] * curl_e[2]) - ii * kappa * tpe[0],
(e->nx[i] * curl_e[2] - e->nz[i] * curl_e[0]) - ii * kappa * tpe[1],
(e->ny[i] * curl_e[0] - e->nx[i] * curl_e[1]) - ii * kappa * tpe[2],
};
// tpv is tangencial projection of v (test function)
scalar vv[3] = { v->val0[i], v->val1[i], v->val2[i] };
scalar tpv[3];
calc_tan_proj(e->nx[i], e->ny[i], e->nz[i], vv, tpv);
result += wt[i] * (g[0] * tpv[0] + g[1] * tpv[1] + g[2] * tpv[2]);
}
return result;
}
int qFinderDMM::bfgs2_Solver(vector<double>& x){
try{
// cout << "bfgs2_Solver" << endl;
int bfgsIter = 0;
double step = 1.0e-6;
double delta_f = 0.0000;//f-f0;
vector<double> gradient;
double f = negativeLogEvidenceLambdaPi(x);
// cout << "after negLE" << endl;
negativeLogDerivEvidenceLambdaPi(x, gradient);
// cout << "after negLDE" << endl;
vector<double> x0 = x;
vector<double> g0 = gradient;
double g0norm = 0;
for(int i=0;i<numOTUs;i++){
g0norm += g0[i] * g0[i];
}
g0norm = sqrt(g0norm);
vector<double> p = gradient;
double pNorm = 0;
for(int i=0;i<numOTUs;i++){
p[i] *= -1 / g0norm;
pNorm += p[i] * p[i];
}
pNorm = sqrt(pNorm);
double df0 = -g0norm;
int maxIter = 5000;
// cout << "before while" << endl;
while(g0norm > 0.001 && bfgsIter++ < maxIter){
if (m->control_pressed) { return 0; }
double f0 = f;
vector<double> dx(numOTUs, 0.0000);
double alphaOld, alphaNew;
if(pNorm == 0 || g0norm == 0 || df0 == 0){
dx.assign(numOTUs, 0.0000);
break;
}
if(delta_f < 0){
double delta = max(-delta_f, 10 * EPSILON * abs(f0));
alphaOld = min(1.0, 2.0 * delta / (-df0));
}
else{
alphaOld = step;
}
int success = lineMinimizeFletcher(x0, p, f0, df0, alphaOld, alphaNew, f, x, gradient);
if(!success){
x = x0;
break;
}
delta_f = f - f0;
vector<double> dx0(numOTUs);
vector<double> dg0(numOTUs);
for(int i=0;i<numOTUs;i++){
dx0[i] = x[i] - x0[i];
dg0[i] = gradient[i] - g0[i];
}
double dxg = 0;
double dgg = 0;
double dxdg = 0;
double dgnorm = 0;
for(int i=0;i<numOTUs;i++){
dxg += dx0[i] * gradient[i];
dgg += dg0[i] * gradient[i];
dxdg += dx0[i] * dg0[i];
dgnorm += dg0[i] * dg0[i];
}
dgnorm = sqrt(dgnorm);
double A, B;
if(dxdg != 0){
B = dxg / dxdg;
A = -(1.0 + dgnorm*dgnorm /dxdg) * B + dgg / dxdg;
}
else{
B = 0;
A = 0;
}
for(int i=0;i<numOTUs;i++){ p[i] = gradient[i] - A * dx0[i] - B * dg0[i]; }
x0 = x;
g0 = gradient;
double pg = 0;
pNorm = 0.0000;
g0norm = 0.0000;
for(int i=0;i<numOTUs;i++){
pg += p[i] * gradient[i];
pNorm += p[i] * p[i];
g0norm += g0[i] * g0[i];
}
pNorm = sqrt(pNorm);
g0norm = sqrt(g0norm);
double dir = (pg >= 0.0) ? -1.0 : +1.0;
for(int i=0;i<numOTUs;i++){ p[i] *= dir / pNorm; }
pNorm = 0.0000;
df0 = 0.0000;
for(int i=0;i<numOTUs;i++){
pNorm += p[i] * p[i];
df0 += p[i] * g0[i];
}
pNorm = sqrt(pNorm);
}
// cout << "bfgsIter:\t" << bfgsIter << endl;
return bfgsIter;
}
catch(exception& e){
m->errorOut(e, "qFinderDMM", "bfgs2_Solver");
exit(1);
}
}
void tri_hp_ps::length() {
int i,j,k,v0,v1,v2,indx,sind,tind,count;
TinyVector<FLT,2> dx0,dx1,dx2,ep,dedpsi;
FLT q,p,duv,um,vm,u,v;
FLT sum,ruv,ratio;
FLT length0,length1,length2,lengthept;
FLT ang1,curved1,ang2,curved2;
FLT norm;
gbl->eanda = 0.0;
for(tind=0;tind<ntri;++tind) {
q = 0.0;
p = 0.0;
duv = 0.0;
um = ug.v(tri(tind).pnt(2),0);
vm = ug.v(tri(tind).pnt(2),1);
for(j=0;j<3;++j) {
v0 = tri(tind).pnt(j);
p += fabs(ug.v(v0,2));
duv += fabs(u-um)+fabs(v-vm);
}
gbl->eanda(0) += 1./3.*(p*area(tind) +duv*gbl->mu*sqrt(area(tind)) );
gbl->eanda(1) += area(tind);
}
sim::blks.allreduce(gbl->eanda.data(),gbl->eanda_recv.data(),2,blocks::flt_msg,blocks::sum);
norm = gbl->eanda_recv(0)/gbl->eanda_recv(1);
gbl->fltwk(Range(0,npnt-1)) = 0.0;
switch(basis::tri(log2p)->p()) {
case(1): {
for(i=0;i<nseg;++i) {
v0 = seg(i).pnt(0);
v1 = seg(i).pnt(1);
ruv = gbl->mu/distance(v0,v1);
sum = distance2(v0,v1)*(ruv*(fabs(ug.v(v0,0) -ug.v(v1,0)) +fabs(ug.v(v0,1) -ug.v(v1,1))) +fabs(ug.v(v0,2) -ug.v(v1,2)));
gbl->fltwk(v0) += sum;
gbl->fltwk(v1) += sum;
}
break;
}
default: {
indx = basis::tri(log2p)->sm()-1;
for(i=0;i<nseg;++i) {
v0 = seg(i).pnt(0);
v1 = seg(i).pnt(1);
ruv = +gbl->mu/distance(v0,v1);
sum = distance2(v0,v1)*(ruv*(fabs(ug.s(i,indx,0)) +fabs(ug.s(i,indx,1))) +fabs(ug.s(i,indx,2)));
gbl->fltwk(v0) += sum;
gbl->fltwk(v1) += sum;
}
/* BOUNDARY CURVATURE */
for(i=0;i<nebd;++i) {
if (!(hp_ebdry(i)->is_curved())) continue;
for(j=0;j<ebdry(i)->nseg;++j) {
sind = ebdry(i)->seg(j);
v1 = seg(sind).pnt(0);
v2 = seg(sind).pnt(1);
crdtocht1d(sind);
/* FIND ANGLE BETWEEN LINEAR SIDES */
tind = seg(sind).tri(0);
for(k=0;k<3;++k)
if (tri(tind).seg(k) == sind) break;
v0 = tri(tind).pnt(k);
dx0(0) = pnts(v2)(0)-pnts(v1)(0);
dx0(1) = pnts(v2)(1)-pnts(v1)(1);
length0 = dx0(0)*dx0(0) +dx0(1)*dx0(1);
dx1(0) = pnts(v0)(0)-pnts(v2)(0);
dx1(1) = pnts(v0)(1)-pnts(v2)(1);
length1 = dx1(0)*dx1(0) +dx1(1)*dx1(1);
dx2(0) = pnts(v1)(0)-pnts(v0)(0);
dx2(1) = pnts(v1)(1)-pnts(v0)(1);
length2 = dx2(0)*dx2(0) +dx2(1)*dx2(1);
basis::tri(log2p)->ptprobe1d(2,&ep(0),&dedpsi(0),-1.0,&cht(0,0),MXTM);
lengthept = dedpsi(0)*dedpsi(0) +dedpsi(1)*dedpsi(1);
ang1 = acos(-(dx0(0)*dx2(0) +dx0(1)*dx2(1))/sqrt(length0*length2));
curved1 = acos((dx0(0)*dedpsi(0) +dx0(1)*dedpsi(1))/sqrt(length0*lengthept));
basis::tri(log2p)->ptprobe1d(2,&ep(0),&dedpsi(0),1.0,&cht(0,0),MXTM);
lengthept = dedpsi(0)*dedpsi(0) +dedpsi(1)*dedpsi(1);
ang2 = acos(-(dx0(0)*dx1(0) +dx0(1)*dx1(1))/sqrt(length0*length1));
curved2 = acos((dx0(0)*dedpsi(0) +dx0(1)*dedpsi(1))/sqrt(length0*lengthept));
sum = gbl->curvature_sensitivity*(curved1/ang1 +curved2/ang2);
gbl->fltwk(v0) += sum*gbl->error_target*norm*pnt(v0).nnbor;
gbl->fltwk(v1) += sum*gbl->error_target*norm*pnt(v1).nnbor;
}
}
break;
}
}
for(i=0;i<npnt;++i) {
gbl->fltwk(i) = pow(gbl->fltwk(i)/(norm*pnt(i).nnbor*gbl->error_target),1./(basis::tri(log2p)->p()+1+ND));
lngth(i) /= gbl->fltwk(i);
}
/* AVOID HIGH ASPECT RATIOS */
int nsweep = 0;
do {
count = 0;
for(i=0;i<nseg;++i) {
v0 = seg(i).pnt(0);
v1 = seg(i).pnt(1);
ratio = lngth(v1)/lngth(v0);
if (ratio > 3.0) {
lngth(v1) = 2.5*lngth(v0);
++count;
}
else if (ratio < 0.333) {
lngth(v0) = 2.5*lngth(v1);
++count;
}
}
++nsweep;
*gbl->log << "#aspect ratio fixes " << nsweep << ' ' << count << std::endl;
} while(count > 0 && nsweep < 5);
return;
}
