bool CPHMovementControl:: ActivateBoxDynamic(DWORD id,int num_it/*=8*/,int num_steps/*5*/,float resolve_depth/*=0.01f*/)
{
bool character_exist=CharacterExist();
if(character_exist&&trying_times[id]!=u32(-1))
{
Fvector dif;dif.sub(trying_poses[id],cast_fv(dBodyGetPosition(m_character->get_body())));
if(Device.dwTimeGlobal-trying_times[id]<500&&dif.magnitude()<0.05f)
return false;
}
if(!m_character||m_character->PhysicsRefObject()->PPhysicsShell())return false;
DWORD old_id=BoxID();
bool character_disabled=character_exist && !m_character->IsEnabled();
if(character_exist&&id==old_id)return true;
if(!character_exist)
{
CreateCharacter();
}
//m_PhysicMovementControl->ActivateBox(id);
m_character->CPHObject::activate();
ph_world->Freeze();
UnFreeze();
saved_callback=ObjectContactCallback();
SetOjectContactCallback(TestDepthCallback);
SetFootCallBack(TestFootDepthCallback);
max_depth=0.f;
//////////////////////////////////pars///////////////////////////////////////////
// int num_it=8;
// int num_steps=5;
// float resolve_depth=0.01f;
if(!character_exist)
{
num_it=20;
num_steps=1;
resolve_depth=0.1f;
}
///////////////////////////////////////////////////////////////////////
float fnum_it=float(num_it);
float fnum_steps=float(num_steps);
float fnum_steps_r=1.f/fnum_steps;
Fvector vel;
Fvector pos;
GetCharacterVelocity(vel);
GetCharacterPosition(pos);
//const Fbox& box =Box();
float pass= character_exist ? _abs(Box().getradius()-boxes[id].getradius()) : boxes[id].getradius();
float max_vel=pass/2.f/fnum_it/fnum_steps/fixed_step;
float max_a_vel=M_PI/8.f/fnum_it/fnum_steps/fixed_step;
dBodySetForce(GetBody(),0.f,0.f,0.f);
dBodySetLinearVel(GetBody(),0.f,0.f,0.f);
Calculate(Fvector().set(0,0,0),Fvector().set(1,0,0),0,0,0,0);
CVelocityLimiter vl(GetBody(),max_vel,max_vel);
max_vel=1.f/fnum_it/fnum_steps/fixed_step;
bool ret=false;
m_character->SwitchOFFInitContact();
vl.Activate();
vl.l_limit*=(fnum_it*fnum_steps/5.f);
vl.y_limit=vl.l_limit;
////////////////////////////////////
for(int m=0;30>m;++m)
{
Calculate(Fvector().set(0,0,0),Fvector().set(1,0,0),0,0,0,0);
EnableCharacter();
m_character->ApplyForce(0,ph_world->Gravity()*m_character->Mass(),0);
max_depth=0.f;
ph_world->Step();
if(max_depth < resolve_depth)
{
break;
}
ph_world->CutVelocity(max_vel,max_a_vel);
}
vl.l_limit/=(fnum_it*fnum_steps/5.f);
vl.y_limit=vl.l_limit;
/////////////////////////////////////
for(int m=0;num_steps>m;++m)
{
float param =fnum_steps_r*(1+m);
InterpolateBox(id,param);
ret=false;
for(int i=0;num_it>i;++i){
max_depth=0.f;
Calculate(Fvector().set(0,0,0),Fvector().set(1,0,0),0,0,0,0);
EnableCharacter();
m_character->ApplyForce(0,ph_world->Gravity()*m_character->Mass(),0);
ph_world->Step();
ph_world->CutVelocity(max_vel,max_a_vel);
if(max_depth < resolve_depth)
{
ret=true;
break;
}
}
if(!ret) break;
}
m_character->SwitchInInitContact();
vl.Deactivate();
ph_world->UnFreeze();
if(!ret)
{
if(!character_exist)DestroyCharacter();
else if(character_disabled)m_character->Disable();
ActivateBox(old_id);
SetVelocity(vel);
dBodyID b=GetBody();
if(b)
{
dMatrix3 R;
dRSetIdentity (R);
dBodySetAngularVel(b,0.f,0.f,0.f);
dBodySetRotation(b,R);
}
SetPosition(pos);
//Msg("can not activate!");
}
else
{
ActivateBox(id);
//Msg("activate!");
}
SetOjectContactCallback(saved_callback);
SetVelocity(vel);
saved_callback=0;
if(!ret&&character_exist)
{
trying_times[id]=Device.dwTimeGlobal;
trying_poses[id].set(cast_fv(dBodyGetPosition(m_character->get_body())));
}
else
{
trying_times[id]=u32(-1);
}
return ret;
}
bool KstFilterDialogI::saveInputs(KstCPluginPtr plugin, KstSharedPtr<Plugin> p) {
KstReadLocker vl(&KST::vectorList.lock());
KstWriteLocker scl(&KST::scalarList.lock());
KstWriteLocker stl(&KST::stringList.lock());
const QValueList<Plugin::Data::IOValue>& itable = p->data()._inputs;
for (QValueList<Plugin::Data::IOValue>::ConstIterator it = itable.begin(); it != itable.end(); ++it) {
if ((*it)._type == Plugin::Data::IOValue::TableType) {
if ((*it)._name == p->data()._filterInputVector) {
KstVectorPtr v = *KST::vectorList.findTag(_yvector);
if (!v) {
return false;
}
plugin->inputVectors().insert((*it)._name, v);
} else {
QObject *field = _w->_pluginInputOutputFrame->child((*it)._name.latin1(), "VectorSelector");
if (field) {
VectorSelector *vs = static_cast<VectorSelector*>(field);
KstVectorPtr v = *KST::vectorList.findTag(vs->selectedVector());
if (!v) {
return false;
}
plugin->inputVectors().insert((*it)._name, v);
}
}
} else if ((*it)._type == Plugin::Data::IOValue::StringType) {
QObject *field = _w->_pluginInputOutputFrame->child((*it)._name.latin1(), "StringSelector");
if (field) {
StringSelector *ss = static_cast<StringSelector*>(field);
KstStringPtr s = *KST::stringList.findTag(ss->selectedString());
if (s == *KST::stringList.end()) {
QString val = ss->_string->currentText();
// create orphan string
KstStringPtr newString = new KstString(KstObjectTag(ss->_string->currentText(), KstObjectTag::orphanTagContext), 0L, val, true);
plugin->inputStrings().insert((*it)._name, newString);
} else {
return false;
}
}
} else if ((*it)._type == Plugin::Data::IOValue::PidType) {
// Nothing
} else {
QObject *field = _w->_pluginInputOutputFrame->child((*it)._name.latin1(), "ScalarSelector");
if (field) {
ScalarSelector *ss = static_cast<ScalarSelector*>(field);
KstScalarPtr s = *KST::scalarList.findTag(ss->selectedScalar());
if (s == *KST::scalarList.end()) {
bool ok;
double val = ss->_scalar->currentText().toDouble(&ok);
if (ok) {
// create orphan scalar
KstScalarPtr newScalar = new KstScalar(KstObjectTag(ss->_scalar->currentText(), KstObjectTag::orphanTagContext), 0L, val, true, false);
plugin->inputScalars().insert((*it)._name, newScalar);
} else {
return false;
}
} else {
plugin->inputScalars().insert((*it)._name, s);
}
}
}
}
return true;
}
int EEBearing3d::update()
{
int rValue = 0;
// get current time
Domain *theDomain = this->getDomain();
(*t)(0) = theDomain->getCurrentTime();
// get global trial response
int ndim = 0, i;
Vector dg(12), vg(12), ag(12), dgDelta(12);
for (i=0; i<2; i++) {
Vector disp = theNodes[i]->getTrialDisp();
Vector vel = theNodes[i]->getTrialVel();
Vector accel = theNodes[i]->getTrialAccel();
Vector dispIncr = theNodes[i]->getIncrDeltaDisp();
dg.Assemble(disp, ndim);
vg.Assemble(vel, ndim);
ag.Assemble(accel, ndim);
dgDelta.Assemble(dispIncr, ndim);
ndim += 6;
}
// transform response from the global to the local system
Vector vl(12), al(12), dlDelta(12);
dl.addMatrixVector(0.0, Tgl, dg, 1.0);
vl.addMatrixVector(0.0, Tgl, vg, 1.0);
al.addMatrixVector(0.0, Tgl, ag, 1.0);
dlDelta.addMatrixVector(0.0, Tgl, dgDelta, 1.0);
// transform response from the local to the basic system
Vector dbDelta(6);
db->addMatrixVector(0.0, Tlb, dl, 1.0);
vb->addMatrixVector(0.0, Tlb, vl, 1.0);
ab->addMatrixVector(0.0, Tlb, al, 1.0);
dbDelta.addMatrixVector(0.0, Tlb, dlDelta, 1.0);
// 1) set axial deformations in basic x-direction
theMaterials[0]->setTrialStrain((*db)(0), (*vb)(0));
if (pFrcCtrl == 1)
(*qb)(0) = theMaterials[0]->getStress();
// 2) set shear deformations in basic y- and z-direction
// do not check time for right now because of transformation constraint
// handler calling update at beginning of new step when applying load
// if (dbDelta.pNorm(0) > DBL_EPSILON || (*t)(0) > tLast) {
if (dbDelta.pNorm(0) > DBL_EPSILON) {
// set the trial response at the site
if (theSite != 0) {
theSite->setTrialResponse(db, vb, ab, qb, t);
}
else {
sData[0] = OF_RemoteTest_setTrialResponse;
rValue += theChannel->sendVector(0, 0, *sendData, 0);
}
}
// 3) set rotations about basic x-direction
theMaterials[1]->setTrialStrain((*db)(3), (*vb)(3));
// 4) set rotations about basic y-direction
theMaterials[2]->setTrialStrain((*db)(4), (*vb)(4));
// 5) set rotations about basic z-direction
theMaterials[3]->setTrialStrain((*db)(5), (*vb)(5));
// save the last time
tLast = (*t)(0);
return rValue;
}
ll tsp(const vvl& g) {
vvl dp(1<<g.size(), vl(g.size(), -1));
return tsp(g, dp, (1<<g.size())-1, 0, g.size());
}
extern "C" magma_int_t
magma_dgeev(
char jobvl, char jobvr, magma_int_t n,
double *A, magma_int_t lda,
double *WR, double *WI,
double *vl, magma_int_t ldvl,
double *vr, magma_int_t ldvr,
double *work, magma_int_t lwork,
magma_int_t *info )
{
/* -- MAGMA (version 1.4.1) --
Univ. of Tennessee, Knoxville
Univ. of California, Berkeley
Univ. of Colorado, Denver
December 2013
Purpose
=======
DGEEV computes for an N-by-N real nonsymmetric matrix A, the
eigenvalues and, optionally, the left and/or right eigenvectors.
The right eigenvector v(j) of A satisfies
A * v(j) = lambda(j) * v(j)
where lambda(j) is its eigenvalue.
The left eigenvector u(j) of A satisfies
u(j)**T * A = lambda(j) * u(j)**T
where u(j)**T denotes the transpose of u(j).
The computed eigenvectors are normalized to have Euclidean norm
equal to 1 and largest component real.
Arguments
=========
JOBVL (input) CHARACTER*1
= 'N': left eigenvectors of A are not computed;
= 'V': left eigenvectors of are computed.
JOBVR (input) CHARACTER*1
= 'N': right eigenvectors of A are not computed;
= 'V': right eigenvectors of A are computed.
N (input) INTEGER
The order of the matrix A. N >= 0.
A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
On entry, the N-by-N matrix A.
On exit, A has been overwritten.
LDA (input) INTEGER
The leading dimension of the array A. LDA >= max(1,N).
WR (output) DOUBLE PRECISION array, dimension (N)
WI (output) DOUBLE PRECISION array, dimension (N)
WR and WI contain the real and imaginary parts,
respectively, of the computed eigenvalues. Complex
conjugate pairs of eigenvalues appear consecutively
with the eigenvalue having the positive imaginary part
first.
VL (output) DOUBLE PRECISION array, dimension (LDVL,N)
If JOBVL = 'V', the left eigenvectors u(j) are stored one
after another in the columns of VL, in the same order
as their eigenvalues.
If JOBVL = 'N', VL is not referenced.
u(j) = VL(:,j), the j-th column of VL.
LDVL (input) INTEGER
The leading dimension of the array VL. LDVL >= 1; if
JOBVL = 'V', LDVL >= N.
VR (output) DOUBLE PRECISION array, dimension (LDVR,N)
If JOBVR = 'V', the right eigenvectors v(j) are stored one
after another in the columns of VR, in the same order
as their eigenvalues.
If JOBVR = 'N', VR is not referenced.
v(j) = VR(:,j), the j-th column of VR.
LDVR (input) INTEGER
The leading dimension of the array VR. LDVR >= 1; if
JOBVR = 'V', LDVR >= N.
WORK (workspace/output) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK (input) INTEGER
The dimension of the array WORK. LWORK >= (2+nb)*N.
For optimal performance, LWORK >= (2+2*nb)*N.
If LWORK = -1, then a workspace query is assumed; the routine
only calculates the optimal size of the WORK array, returns
this value as the first entry of the WORK array, and no error
message related to LWORK is issued by XERBLA.
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: if INFO = i, the QR algorithm failed to compute all the
eigenvalues, and no eigenvectors have been computed;
elements and i+1:N of W contain eigenvalues which have
converged.
===================================================================== */
#define vl(i,j) (vl + (i) + (j)*ldvl)
#define vr(i,j) (vr + (i) + (j)*ldvr)
magma_int_t c_one = 1;
magma_int_t c_zero = 0;
double d__1, d__2;
double r, cs, sn, scl;
double dum[1], eps;
double anrm, cscale, bignum, smlnum;
magma_int_t i, k, ilo, ihi;
magma_int_t ibal, ierr, itau, iwrk, nout, liwrk, i__1, i__2, nb;
magma_int_t scalea, minwrk, lquery, wantvl, wantvr, select[1];
char side[2] = {0, 0};
char jobvl_[2] = {jobvl, 0};
char jobvr_[2] = {jobvr, 0};
*info = 0;
lquery = lwork == -1;
wantvl = lapackf77_lsame( jobvl_, "V" );
wantvr = lapackf77_lsame( jobvr_, "V" );
if (! wantvl && ! lapackf77_lsame( jobvl_, "N" )) {
*info = -1;
} else if (! wantvr && ! lapackf77_lsame( jobvr_, "N" )) {
*info = -2;
} else if (n < 0) {
*info = -3;
} else if (lda < max(1,n)) {
*info = -5;
} else if ( (ldvl < 1) || (wantvl && (ldvl < n))) {
*info = -9;
} else if ( (ldvr < 1) || (wantvr && (ldvr < n))) {
*info = -11;
}
/* Compute workspace */
nb = magma_get_dgehrd_nb( n );
if (*info == 0) {
minwrk = (2+nb)*n;
work[0] = MAGMA_D_MAKE( (double) minwrk, 0. );
if (lwork < minwrk && ! lquery) {
*info = -13;
}
}
if (*info != 0) {
magma_xerbla( __func__, -(*info) );
return *info;
}
else if (lquery) {
return *info;
}
/* Quick return if possible */
if (n == 0) {
return *info;
}
#if defined(VERSION3)
double *dT;
if (MAGMA_SUCCESS != magma_dmalloc( &dT, nb*n )) {
*info = MAGMA_ERR_DEVICE_ALLOC;
return *info;
}
#endif
/* Get machine constants */
eps = lapackf77_dlamch( "P" );
smlnum = lapackf77_dlamch( "S" );
bignum = 1. / smlnum;
lapackf77_dlabad( &smlnum, &bignum );
smlnum = magma_dsqrt( smlnum ) / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = lapackf77_dlange( "M", &n, &n, A, &lda, dum );
scalea = 0;
if (anrm > 0. && anrm < smlnum) {
scalea = 1;
cscale = smlnum;
} else if (anrm > bignum) {
scalea = 1;
cscale = bignum;
}
if (scalea) {
lapackf77_dlascl( "G", &c_zero, &c_zero, &anrm, &cscale, &n, &n, A, &lda, &ierr );
}
/* Balance the matrix
* (Workspace: need N) */
ibal = 0;
lapackf77_dgebal( "B", &n, A, &lda, &ilo, &ihi, &work[ibal], &ierr );
/* Reduce to upper Hessenberg form
* (Workspace: need 3*N, prefer 2*N + N*NB) */
itau = ibal + n;
iwrk = itau + n;
liwrk = lwork - iwrk;
#if defined(VERSION1)
// Version 1 - LAPACK
lapackf77_dgehrd( &n, &ilo, &ihi, A, &lda,
&work[itau], &work[iwrk], &liwrk, &ierr );
#elif defined(VERSION2)
// Version 2 - LAPACK consistent HRD
magma_dgehrd2( n, ilo, ihi, A, lda,
&work[itau], &work[iwrk], liwrk, &ierr );
#elif defined(VERSION3)
// Version 3 - LAPACK consistent MAGMA HRD + T matrices stored,
magma_dgehrd( n, ilo, ihi, A, lda,
&work[itau], &work[iwrk], liwrk, dT, &ierr );
#endif
if (wantvl) {
/* Want left eigenvectors
* Copy Householder vectors to VL */
side[0] = 'L';
lapackf77_dlacpy( MagmaLowerStr, &n, &n,
A, &lda, vl, &ldvl );
/* Generate orthogonal matrix in VL
* (Workspace: need 3*N-1, prefer 2*N + (N-1)*NB) */
#if defined(VERSION1) || defined(VERSION2)
// Version 1 & 2 - LAPACK
lapackf77_dorghr( &n, &ilo, &ihi, vl, &ldvl, &work[itau],
&work[iwrk], &liwrk, &ierr );
#elif defined(VERSION3)
// Version 3 - LAPACK consistent MAGMA HRD + T matrices stored
magma_dorghr( n, ilo, ihi, vl, ldvl, &work[itau], dT, nb, &ierr );
#endif
/* Perform QR iteration, accumulating Schur vectors in VL
* (Workspace: need N+1, prefer N+HSWORK (see comments) ) */
iwrk = itau;
liwrk = lwork - iwrk;
lapackf77_dhseqr( "S", "V", &n, &ilo, &ihi, A, &lda, WR, WI,
vl, &ldvl, &work[iwrk], &liwrk, info );
if (wantvr) {
/* Want left and right eigenvectors
* Copy Schur vectors to VR */
side[0] = 'B';
lapackf77_dlacpy( "F", &n, &n, vl, &ldvl, vr, &ldvr );
}
}
else if (wantvr) {
/* Want right eigenvectors
* Copy Householder vectors to VR */
side[0] = 'R';
lapackf77_dlacpy( "L", &n, &n, A, &lda, vr, &ldvr );
/* Generate orthogonal matrix in VR
* (Workspace: need 3*N-1, prefer 2*N + (N-1)*NB) */
#if defined(VERSION1) || defined(VERSION2)
// Version 1 & 2 - LAPACK
lapackf77_dorghr( &n, &ilo, &ihi, vr, &ldvr, &work[itau],
&work[iwrk], &liwrk, &ierr );
#elif defined(VERSION3)
// Version 3 - LAPACK consistent MAGMA HRD + T matrices stored
magma_dorghr( n, ilo, ihi, vr, ldvr, &work[itau], dT, nb, &ierr );
#endif
/* Perform QR iteration, accumulating Schur vectors in VR
* (Workspace: need N+1, prefer N+HSWORK (see comments) ) */
iwrk = itau;
liwrk = lwork - iwrk;
lapackf77_dhseqr( "S", "V", &n, &ilo, &ihi, A, &lda, WR, WI,
vr, &ldvr, &work[iwrk], &liwrk, info );
}
else {
/* Compute eigenvalues only
* (Workspace: need N+1, prefer N+HSWORK (see comments) ) */
iwrk = itau;
liwrk = lwork - iwrk;
lapackf77_dhseqr( "E", "N", &n, &ilo, &ihi, A, &lda, WR, WI,
vr, &ldvr, &work[iwrk], &liwrk, info );
}
/* If INFO > 0 from DHSEQR, then quit */
if (*info > 0) {
goto CLEANUP;
}
if (wantvl || wantvr) {
/* Compute left and/or right eigenvectors
* (Workspace: need 4*N) */
liwrk = lwork - iwrk;
#if TREVC_VERSION == 1
lapackf77_dtrevc( side, "B", select, &n, A, &lda, vl, &ldvl,
vr, &ldvr, &n, &nout, &work[iwrk], &ierr );
#elif TREVC_VERSION == 2
lapackf77_dtrevc3( side, "B", select, &n, A, &lda, vl, &ldvl,
vr, &ldvr, &n, &nout, &work[iwrk], &liwrk, &ierr );
#endif
}
if (wantvl) {
/* Undo balancing of left eigenvectors
* (Workspace: need N) */
lapackf77_dgebak( "B", "L", &n, &ilo, &ihi, &work[ibal], &n,
vl, &ldvl, &ierr );
/* Normalize left eigenvectors and make largest component real */
for (i = 0; i < n; ++i) {
if ( WI[i] == 0. ) {
scl = 1. / cblas_dnrm2( n, vl(0,i), 1 );
cblas_dscal( n, scl, vl(0,i), 1 );
}
else if ( WI[i] > 0. ) {
d__1 = cblas_dnrm2( n, vl(0,i), 1 );
d__2 = cblas_dnrm2( n, vl(0,i+1), 1 );
scl = 1. / lapackf77_dlapy2( &d__1, &d__2 );
cblas_dscal( n, scl, vl(0,i), 1 );
cblas_dscal( n, scl, vl(0,i+1), 1 );
for (k = 0; k < n; ++k) {
/* Computing 2nd power */
d__1 = *vl(k,i);
d__2 = *vl(k,i+1);
work[iwrk + k] = d__1*d__1 + d__2*d__2;
}
k = cblas_idamax( n, &work[iwrk], 1 );
lapackf77_dlartg( vl(k,i), vl(k,i+1), &cs, &sn, &r );
cblas_drot( n, vl(0,i), 1, vl(0,i+1), 1, cs, sn );
*vl(k,i+1) = 0.;
}
}
}
if (wantvr) {
/* Undo balancing of right eigenvectors
* (Workspace: need N) */
lapackf77_dgebak( "B", "R", &n, &ilo, &ihi, &work[ibal], &n,
vr, &ldvr, &ierr );
/* Normalize right eigenvectors and make largest component real */
for (i = 0; i < n; ++i) {
if ( WI[i] == 0. ) {
scl = 1. / cblas_dnrm2( n, vr(0,i), 1 );
cblas_dscal( n, scl, vr(0,i), 1 );
}
else if ( WI[i] > 0. ) {
d__1 = cblas_dnrm2( n, vr(0,i), 1 );
d__2 = cblas_dnrm2( n, vr(0,i+1), 1 );
scl = 1. / lapackf77_dlapy2( &d__1, &d__2 );
cblas_dscal( n, scl, vr(0,i), 1 );
cblas_dscal( n, scl, vr(0,i+1), 1 );
for (k = 0; k < n; ++k) {
/* Computing 2nd power */
d__1 = *vr(k,i);
d__2 = *vr(k,i+1);
work[iwrk + k] = d__1*d__1 + d__2*d__2;
}
k = cblas_idamax( n, &work[iwrk], 1 );
lapackf77_dlartg( vr(k,i), vr(k,i+1), &cs, &sn, &r );
cblas_drot( n, vr(0,i), 1, vr(0,i+1), 1, cs, sn );
*vr(k,i+1) = 0.;
}
}
}
CLEANUP:
/* Undo scaling if necessary */
if (scalea) {
i__1 = n - (*info);
i__2 = max( n - (*info), 1 );
lapackf77_dlascl( "G", &c_zero, &c_zero, &cscale, &anrm, &i__1, &c_one,
WR + (*info), &i__2, &ierr );
lapackf77_dlascl( "G", &c_zero, &c_zero, &cscale, &anrm, &i__1, &c_one,
WI + (*info), &i__2, &ierr );
if (*info > 0) {
i__1 = ilo - 1;
lapackf77_dlascl( "G", &c_zero, &c_zero, &cscale, &anrm, &i__1, &c_one,
WR, &n, &ierr );
lapackf77_dlascl( "G", &c_zero, &c_zero, &cscale, &anrm, &i__1, &c_one,
WI, &n, &ierr );
}
}
#if defined(VERSION3)
magma_free( dT );
#endif
return *info;
} /* magma_dgeev */
void MythRenderOpenGL2::DrawRoundRectPriv(const QRect &area, int cornerRadius,
const QBrush &fillBrush,
const QPen &linePen, int alpha)
{
int lineWidth = linePen.width();
int halfline = lineWidth / 2;
int rad = cornerRadius - halfline;
if ((area.width() / 2) < rad)
rad = area.width() / 2;
if ((area.height() / 2) < rad)
rad = area.height() / 2;
int dia = rad * 2;
QRect r(area.left() + halfline, area.top() + halfline,
area.width() - (halfline * 2), area.height() - (halfline * 2));
QRect tl(r.left(), r.top(), rad, rad);
QRect tr(r.left() + r.width() - rad, r.top(), rad, rad);
QRect bl(r.left(), r.top() + r.height() - rad, rad, rad);
QRect br(r.left() + r.width() - rad, r.top() + r.height() - rad, rad, rad);
SetBlend(true);
DisableTextures();
m_glEnableVertexAttribArray(VERTEX_INDEX);
if (fillBrush.style() != Qt::NoBrush)
{
// Get the shaders
int elip = m_shaders[kShaderCircle];
int fill = m_shaders[kShaderSimple];
// Set the fill color
m_glVertexAttrib4f(COLOR_INDEX,
fillBrush.color().red() / 255.0,
fillBrush.color().green() / 255.0,
fillBrush.color().blue() / 255.0,
(fillBrush.color().alpha() / 255.0) * (alpha / 255.0));
// Set the radius
m_parameters[0][2] = rad;
m_parameters[0][3] = rad - 1.0;
// Enable the Circle shader
SetShaderParams(elip, &m_projection[0][0], "u_projection");
SetShaderParams(elip, &m_transforms.top().m[0][0], "u_transform");
// Draw the top left segment
m_parameters[0][0] = tl.left() + rad;
m_parameters[0][1] = tl.top() + rad;
SetShaderParams(elip, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, tl);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Draw the top right segment
m_parameters[0][0] = tr.left();
m_parameters[0][1] = tr.top() + rad;
SetShaderParams(elip, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, tr);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Draw the bottom left segment
m_parameters[0][0] = bl.left() + rad;
m_parameters[0][1] = bl.top();
SetShaderParams(elip, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, bl);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Draw the bottom right segment
m_parameters[0][0] = br.left();
m_parameters[0][1] = br.top();
SetShaderParams(elip, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, br);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Fill the remaining areas
QRect main(r.left() + rad, r.top(), r.width() - dia, r.height());
QRect left(r.left(), r.top() + rad, rad, r.height() - dia);
QRect right(r.left() + r.width() - rad, r.top() + rad, rad, r.height() - dia);
EnableShaderObject(fill);
SetShaderParams(fill, &m_projection[0][0], "u_projection");
SetShaderParams(fill, &m_transforms.top().m[0][0], "u_transform");
GetCachedVBO(GL_TRIANGLE_STRIP, main);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
GetCachedVBO(GL_TRIANGLE_STRIP, left);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
GetCachedVBO(GL_TRIANGLE_STRIP, right);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
m_glBindBuffer(GL_ARRAY_BUFFER, 0);
}
if (linePen.style() != Qt::NoPen)
{
// Get the shaders
int edge = m_shaders[kShaderCircleEdge];
int vline = m_shaders[kShaderVertLine];
int hline = m_shaders[kShaderHorizLine];
// Set the line color
m_glVertexAttrib4f(COLOR_INDEX,
linePen.color().red() / 255.0,
linePen.color().green() / 255.0,
linePen.color().blue() / 255.0,
(linePen.color().alpha() / 255.0) * (alpha / 255.0));
// Set the radius and width
m_parameters[0][2] = rad - lineWidth / 2.0;
m_parameters[0][3] = lineWidth / 2.0;
// Enable the edge shader
SetShaderParams(edge, &m_projection[0][0], "u_projection");
SetShaderParams(edge, &m_transforms.top().m[0][0], "u_transform");
// Draw the top left edge segment
m_parameters[0][0] = tl.left() + rad;
m_parameters[0][1] = tl.top() + rad;
SetShaderParams(edge, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, tl);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Draw the top right edge segment
m_parameters[0][0] = tr.left();
m_parameters[0][1] = tr.top() + rad;
SetShaderParams(edge, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, tr);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Draw the bottom left edge segment
m_parameters[0][0] = bl.left() + rad;
m_parameters[0][1] = bl.top();
SetShaderParams(edge, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, bl);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Draw the bottom right edge segment
m_parameters[0][0] = br.left();
m_parameters[0][1] = br.top();
SetShaderParams(edge, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, br);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Vertical lines
SetShaderParams(vline, &m_projection[0][0], "u_projection");
SetShaderParams(vline, &m_transforms.top().m[0][0], "u_transform");
m_parameters[0][1] = lineWidth / 2.0;
QRect vl(r.left(), r.top() + rad,
lineWidth, r.height() - dia);
// Draw the left line segment
m_parameters[0][0] = vl.left() + lineWidth;
SetShaderParams(vline, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, vl);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Draw the right line segment
vl.translate(r.width() - lineWidth, 0);
m_parameters[0][0] = vl.left();
SetShaderParams(vline, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, vl);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Horizontal lines
SetShaderParams(hline, &m_projection[0][0], "u_projection");
SetShaderParams(hline, &m_transforms.top().m[0][0], "u_transform");
QRect hl(r.left() + rad, r.top(),
r.width() - dia, lineWidth);
// Draw the top line segment
m_parameters[0][0] = hl.top() + lineWidth;
SetShaderParams(hline, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, hl);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Draw the bottom line segment
hl.translate(0, r.height() - lineWidth);
m_parameters[0][0] = hl.top();
SetShaderParams(hline, &m_parameters[0][0], "u_parameters");
GetCachedVBO(GL_TRIANGLE_STRIP, hl);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
m_glBindBuffer(GL_ARRAY_BUFFER, 0);
}
m_glDisableVertexAttribArray(VERTEX_INDEX);
}
int main(int argc, char *argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (iprint > 0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
// *** Example body.
try {
Teuchos::RCP<ROL::Objective<RealT> > obj;
Teuchos::RCP<ROL::EqualityConstraint<RealT> > constr;
Teuchos::RCP<std::vector<RealT> > x_rcp = Teuchos::rcp( new std::vector<RealT> (0, 0.0) );
Teuchos::RCP<std::vector<RealT> > sol_rcp = Teuchos::rcp( new std::vector<RealT> (0, 0.0) );
ROL::StdVector<RealT> x(x_rcp); // Iteration vector.
ROL::StdVector<RealT> sol(sol_rcp); // Reference solution vector.
// Retrieve objective, constraint, iteration vector, solution vector.
ROL::ZOO::getSimpleEqConstrained <RealT, ROL::StdVector<RealT>, ROL::StdVector<RealT>, ROL::StdVector<RealT>, ROL::StdVector<RealT> > (obj, constr, x, sol);
Teuchos::ParameterList parlist;
// Define Step
parlist.set("Nominal SQP Optimality Solver Tolerance", 1.e-2);
ROL::CompositeStepSQP<RealT> step(parlist);
// Run derivative checks, etc.
int dim = 5;
int nc = 3;
RealT left = -1e0, right = 1e0;
Teuchos::RCP<std::vector<RealT> > xtest_rcp = Teuchos::rcp( new std::vector<RealT> (dim, 0.0) );
Teuchos::RCP<std::vector<RealT> > g_rcp = Teuchos::rcp( new std::vector<RealT> (dim, 0.0) );
Teuchos::RCP<std::vector<RealT> > d_rcp = Teuchos::rcp( new std::vector<RealT> (dim, 0.0) );
Teuchos::RCP<std::vector<RealT> > v_rcp = Teuchos::rcp( new std::vector<RealT> (dim, 0.0) );
Teuchos::RCP<std::vector<RealT> > vc_rcp = Teuchos::rcp( new std::vector<RealT> (nc, 0.0) );
Teuchos::RCP<std::vector<RealT> > vl_rcp = Teuchos::rcp( new std::vector<RealT> (nc, 0.0) );
ROL::StdVector<RealT> xtest(xtest_rcp);
ROL::StdVector<RealT> g(g_rcp);
ROL::StdVector<RealT> d(d_rcp);
ROL::StdVector<RealT> v(v_rcp);
ROL::StdVector<RealT> vc(vc_rcp);
ROL::StdVector<RealT> vl(vl_rcp);
// set xtest, d, v
for (int i=0; i<dim; i++) {
(*xtest_rcp)[i] = ( (RealT)rand() / (RealT)RAND_MAX ) * (right - left) + left;
(*d_rcp)[i] = ( (RealT)rand() / (RealT)RAND_MAX ) * (right - left) + left;
(*v_rcp)[i] = ( (RealT)rand() / (RealT)RAND_MAX ) * (right - left) + left;
}
// set vc, vl
for (int i=0; i<nc; i++) {
(*vc_rcp)[i] = ( (RealT)rand() / (RealT)RAND_MAX ) * (right - left) + left;
(*vl_rcp)[i] = ( (RealT)rand() / (RealT)RAND_MAX ) * (right - left) + left;
}
obj->checkGradient(xtest, d, true, *outStream); *outStream << "\n";
obj->checkHessVec(xtest, v, true, *outStream); *outStream << "\n";
obj->checkHessSym(xtest, d, v, true, *outStream); *outStream << "\n";
constr->checkApplyJacobian(xtest, v, vc, true, *outStream); *outStream << "\n";
constr->checkApplyAdjointJacobian(xtest, vl, vc, xtest, true, *outStream); *outStream << "\n";
constr->checkApplyAdjointHessian(xtest, vl, d, xtest, true, *outStream); *outStream << "\n";
Teuchos::RCP<std::vector<RealT> > v1_rcp = Teuchos::rcp( new std::vector<RealT> (dim, 0.0) );
Teuchos::RCP<std::vector<RealT> > v2_rcp = Teuchos::rcp( new std::vector<RealT> (nc, 0.0) );
ROL::StdVector<RealT> v1(v1_rcp);
ROL::StdVector<RealT> v2(v2_rcp);
RealT augtol = 1e-8;
constr->solveAugmentedSystem(v1, v2, d, vc, xtest, augtol);
// Define Status Test
RealT gtol = 1e-12; // norm of gradient tolerance
RealT ctol = 1e-12; // norm of constraint tolerance
RealT stol = 1e-18; // norm of step tolerance
int maxit = 1000; // maximum number of iterations
ROL::StatusTestSQP<RealT> status(gtol, ctol, stol, maxit);
// Define Algorithm
ROL::DefaultAlgorithm<RealT> algo(step, status, false);
// Run Algorithm
vl.zero();
//(*x_rcp)[0] = 3.0; (*x_rcp)[1] = 2.0; (*x_rcp)[2] = 2.0; (*x_rcp)[3] = 1.0; (*x_rcp)[4] = 1.0;
//(*x_rcp)[0] = -5.0; (*x_rcp)[1] = -5.0; (*x_rcp)[2] = -5.0; (*x_rcp)[3] = -6.0; (*x_rcp)[4] = -6.0;
std::vector<std::string> output = algo.run(x, g, vl, vc, *obj, *constr, false);
for ( unsigned i = 0; i < output.size(); i++ ) {
*outStream << output[i];
}
// Compute Error
*outStream << "\nReference solution x_r =\n";
*outStream << std::scientific << " " << (*sol_rcp)[0] << "\n";
*outStream << std::scientific << " " << (*sol_rcp)[1] << "\n";
*outStream << std::scientific << " " << (*sol_rcp)[2] << "\n";
*outStream << std::scientific << " " << (*sol_rcp)[3] << "\n";
*outStream << std::scientific << " " << (*sol_rcp)[4] << "\n";
*outStream << "\nOptimal solution x =\n";
*outStream << std::scientific << " " << (*x_rcp)[0] << "\n";
*outStream << std::scientific << " " << (*x_rcp)[1] << "\n";
*outStream << std::scientific << " " << (*x_rcp)[2] << "\n";
*outStream << std::scientific << " " << (*x_rcp)[3] << "\n";
*outStream << std::scientific << " " << (*x_rcp)[4] << "\n";
x.axpy(-1.0, sol);
RealT abserr = x.norm();
RealT relerr = abserr/sol.norm();
*outStream << std::scientific << "\n Absolute Error: " << abserr;
*outStream << std::scientific << "\n Relative Error: " << relerr << "\n";
if ( relerr > sqrt(ROL::ROL_EPSILON) ) {
errorFlag += 1;
}
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
