void fiberForwardModel( float fiber[3][MAX_FIB_LEN], unsigned int pts ) { static Vector<double> S1, S2, S1m, S2m, P; static Vector<double> vox, vmin, vmax, dir; static double len, t; static int i, j, k; FiberSegments.clear(); for(i=nPointsToSkip; i<pts-1-nPointsToSkip ;i++) { // original segment to be processed S1.Set( fiber[0][i] + fiberShiftXmm, fiber[1][i] + fiberShiftYmm, fiber[2][i] + fiberShiftZmm ); S2.Set( fiber[0][i+1] + fiberShiftXmm, fiber[1][i+1] + fiberShiftYmm, fiber[2][i+1] + fiberShiftZmm ); // get a normal to the vector to move dir.x = S2.x-S1.x; dir.y = S2.y-S1.y; dir.z = S2.z-S1.z; dir.Normalize(); if ( doIntersect==false ) segmentForwardModel( S1, S2 ); else while( 1 ) { len = sqrt( pow(S2.x-S1.x,2) + pow(S2.y-S1.y,2) + pow(S2.z-S1.z,2) ); // in mm if ( len <= minSegLen ) break; // compute AABB of the first point (in mm) vmin.x = floor( (S1.x + 1e-6*dir.x)/pixdim.x ) * pixdim.x; vmin.y = floor( (S1.y + 1e-6*dir.y)/pixdim.y ) * pixdim.y; vmin.z = floor( (S1.z + 1e-6*dir.z)/pixdim.z ) * pixdim.z; vmax.x = vmin.x + pixdim.x; vmax.y = vmin.y + pixdim.y; vmax.z = vmin.z + pixdim.z; if ( rayBoxIntersection( S1, dir, vmin, vmax, t ) && t>0 && t<len ) { // add the portion S1P, and then reiterate P.Set( S1.x + t*dir.x, S1.y + t*dir.y, S1.z + t*dir.z ); segmentForwardModel( S1, P ); S1.Set( P.x, P.y, P.z ); } else { // add the segment S1S2 and stop iterating segmentForwardModel( S1, S2 ); break; } } } }
void SymScaledMatrix::MultVectorImpl(Number alpha, const Vector &x, Number beta, Vector &y) const { DBG_ASSERT(IsValid(matrix_)); // Take care of the y part of the addition if ( beta!=0.0 ) { y.Scal(beta); } else { y.Set(0.0); // In case y hasn't been initialized yet } // need some temporary vectors SmartPtr<Vector> tmp_x = x.MakeNewCopy(); SmartPtr<Vector> tmp_y = y.MakeNew(); if (IsValid(owner_space_->RowColScaling())) { tmp_x->ElementWiseMultiply(*owner_space_->RowColScaling()); } matrix_->MultVector(1.0, *tmp_x, 0.0, *tmp_y); if (IsValid(owner_space_->RowColScaling())) { tmp_y->ElementWiseMultiply(*owner_space_->RowColScaling()); } y.Axpy(1.0, *tmp_y); }
void MultiVectorMatrix::LRMultVector(Number alpha, const Vector &x, Number beta, Vector &y) const { DBG_START_METH("MultiVectorMatrix::LRMultVector(", dbg_verbosity); DBG_ASSERT(NRows()==x.Dim()); DBG_ASSERT(NRows()==y.Dim()); DBG_PRINT((1, "alpha = %e beta = %e\n", alpha, beta)); DBG_PRINT_VECTOR(2, "x", x); if ( beta!=0.0 ) { y.Scal(beta); } else { y.Set(0.0); } DBG_PRINT_VECTOR(2, "beta*y", y); for (Index i=0; i<NCols(); i++) { DBG_PRINT_VECTOR(2, "ConstVec(i)", *ConstVec(i)); y.AddOneVector(alpha*ConstVec(i)->Dot(x), *ConstVec(i), 1.); DBG_PRINT_VECTOR(2, "y mid", y); } }
void MultiVectorMatrix::MultVectorImpl(Number alpha, const Vector &x, Number beta, Vector &y) const { // A few sanity checks DBG_ASSERT(NCols()==x.Dim()); DBG_ASSERT(NRows()==y.Dim()); // Take care of the y part of the addition if ( beta!=0.0 ) { y.Scal(beta); } else { y.Set(0.0); // In case y hasn't been initialized yet } // See if we can understand the data const DenseVector* dense_x = static_cast<const DenseVector*>(&x); DBG_ASSERT(dynamic_cast<const DenseVector*>(&x)); // We simply add all the Vectors one after the other if (dense_x->IsHomogeneous()) { Number val = dense_x->Scalar(); for (Index i=0; i<NCols(); i++) { y.AddOneVector(alpha*val, *ConstVec(i), 1.); } } else { const Number* values = dense_x->Values(); for (Index i=0; i<NCols(); i++) { y.AddOneVector(alpha*values[i], *ConstVec(i), 1.); } } }
float Plane::DistToPoint(float x, float y, float z) { Vector p; p.Set(x, y, z); return m_normal.Dot(p) + m_d; }
void SymTMatrix::MultVectorImpl(Number alpha, const Vector &x, Number beta, Vector &y) const { // A few sanity checks DBG_ASSERT(Dim()==x.Dim()); DBG_ASSERT(Dim()==y.Dim()); // Take care of the y part of the addition DBG_ASSERT(initialized_); if( beta!=0.0 ) { y.Scal(beta); } else { y.Set(0.0); // In case y hasn't been initialized yet } // See if we can understand the data const DenseVector* dense_x = dynamic_cast<const DenseVector*>(&x); DBG_ASSERT(dense_x); /* ToDo: Implement others */ DenseVector* dense_y = dynamic_cast<DenseVector*>(&y); DBG_ASSERT(dense_y); /* ToDo: Implement others */ if (dense_x && dense_y) { const Index* irn=Irows(); const Index* jcn=Jcols(); const Number* val=values_; Number* yvals=dense_y->Values(); if (dense_x->IsHomogeneous()) { Number as = alpha * dense_x->Scalar(); for(Index i=0; i<Nonzeros(); i++) { yvals[*irn-1] += as * (*val); if (*irn!=*jcn) { // this is not a diagonal element yvals[*jcn-1] += as * (*val); } val++; irn++; jcn++; } } else { const Number* xvals=dense_x->Values(); for(Index i=0; i<Nonzeros(); i++) { yvals[*irn-1] += alpha* (*val) * xvals[*jcn-1]; if (*irn!=*jcn) { // this is not a diagonal element yvals[*jcn-1] += alpha* (*val) * xvals[*irn-1]; } val++; irn++; jcn++; } } } }
Vector CStar::NearestStar(Vector _oldnear){ if (Alive){ Vector vsMePos; vsMePos.Set(DrawPos.x-WINDOW_WIDTH/2, DrawPos.y-WINDOW_HEIGHT/2); if (vsMePos.GetLength() < _oldnear.GetLength()){ return vsMePos; } } return _oldnear; }
void Vector::GetRightUp(Vector &right, Vector &up) { Vector n(X(), Y(), Z()); Vector fn(fabsf(n.X()), fabsf(n.Y()), fabsf(n.Z())); int major = 0; if (fn[1] > fn[major]) major = 1; if (fn[2] > fn[major]) major = 2; // build right vector by hand if (fabsf(fn[0]-1.0f) < FLT_EPSILON || fabsf(fn[1]-1.0f) < FLT_EPSILON || fabsf(fn[2]-1.0f) < FLT_EPSILON) { if (major == 0 && n[0] > 0.f) { right.Set(0.f, 0.f, -1.f); } else if (major == 0) { right.Set(0.f, 0.f, 1.f); } if (major == 1 || (major == 2 && n[2] > 0.f)) { right.Set(1.f, 0.f, 0.f); } if (major == 2 && n[2] < 0.0f) { right.Set(-1.f, 0.f, 0.f); } } else { right = axis[major].Cross(n); } up = n.Cross(right); right.Normalize(); up.Normalize(); }
Vector Vector::operator+ (Vector &v) { float x, y, z; Vector vec; x = X() + v.X(); y = Y() + v.Y(); z = Z() + v.Z(); vec.Set(x, y, z); return vec; }
Vector Vector::Cross(Vector &v) { float x, y, z; Vector cp; x = Y() * v.Z() - Z() * v.Y(); y = Z() * v.X() - X() * v.Z(); z = X() * v.Y() - Y() * v.X(); cp.Set(x, y, z); return cp; }
void CEnemy::Move(Vector _mypos, Vector _starpos, int _timecount){ if(Alive){ if(_timecount-AppearTime>=AliveTime){ Alive=FALSE; } if(MoveType==0){ //ランダム直進 } if(MoveType==1){ //自機追尾 Vector direction; direction = GetDirection(_mypos); direction.Multiple(0.2); Velocity.Add(direction); if(Velocity.GetLength()>MaxSpeed) Velocity.Multiple(MaxSpeed/Velocity.GetLength()); } if(MoveType==2){ //母星追尾 Vector direction; direction = GetDirection(_starpos); direction.Multiple(0.1); Velocity.Add(direction); if(Velocity.GetLength()>MaxSpeed) Velocity.Multiple(MaxSpeed/Velocity.GetLength()); } if(MoveType==3){ //出現速度で回転移動 Vector acceleration; int r = 240; acceleration.Set(cos((long double)(_timecount-AppearTime)*MaxSpeed/r),sin((long double)(_timecount-AppearTime)*MaxSpeed/r)); acceleration.Multiple(-1*r*(MaxSpeed/r)*(MaxSpeed/r)); Velocity.Add(acceleration); if(Velocity.GetLength()>MaxSpeed) Velocity.Multiple(MaxSpeed/Velocity.GetLength()); } if(MoveType==4){ //母星の周りを回転移動 int spin_begin_time = 100; if(_timecount-AppearTime==spin_begin_time){ Velocity.Set(0, 0); AngleSpeed = (MaxSpeed/(Pos.x-_starpos.x)); //角速度設定 }else if(_timecount-AppearTime>spin_begin_time){ Pos.Set(_starpos.x + MaxSpeed*cos((_timecount-AppearTime-spin_begin_time)*AngleSpeed)/AngleSpeed, _starpos.y + MaxSpeed*sin((_timecount-AppearTime-spin_begin_time)*AngleSpeed)/AngleSpeed); } } Pos.Add(Velocity); if(Pos.x>WORLD_WIDTH)Pos.x-=WORLD_WIDTH; if(Pos.x<0)Pos.x+=WORLD_WIDTH; if(Pos.y>WORLD_HEIGHT)Pos.y-=WORLD_HEIGHT; if(Pos.y<0)Pos.y+=WORLD_HEIGHT; } }
void GenTMatrix::TransMultVectorImpl(Number alpha, const Vector &x, Number beta, Vector &y) const { // A few sanity checks DBG_ASSERT(NCols()==y.Dim()); DBG_ASSERT(NRows()==x.Dim()); // Take care of the y part of the addition DBG_ASSERT(initialized_); if ( beta!=0.0 ) { y.Scal(beta); } else { y.Set(0.0); // In case y hasn't been initialized yet } // See if we can understand the data const DenseVector* dense_x = static_cast<const DenseVector*>(&x); DBG_ASSERT(dynamic_cast<const DenseVector*>(&x)); DenseVector* dense_y = static_cast<DenseVector*>(&y); DBG_ASSERT(dynamic_cast<DenseVector*>(&y)); if (dense_x && dense_y) { const Index* irows=Irows(); const Index* jcols=Jcols(); const Number* val=values_; Number* yvals=dense_y->Values(); yvals--; if (dense_x->IsHomogeneous()) { Number as = alpha * dense_x->Scalar(); for (Index i=0; i<Nonzeros(); i++) { yvals[*jcols] += as * (*val); val++; jcols++; } } else { const Number* xvals=dense_x->Values(); xvals--; for (Index i=0; i<Nonzeros(); i++) { yvals[*jcols] += alpha* (*val) * xvals[*irows]; val++; irows++; jcols++; } } } }
void ZeroMatrix::TransMultVectorImpl(Number alpha, const Vector &x, Number beta, Vector &y) const { // A few sanity checks DBG_ASSERT(NCols()==y.Dim()); DBG_ASSERT(NRows()==x.Dim()); // Take care of the y part of the addition if ( beta!=0.0 ) { y.Scal(beta); } else { y.Set(0.0); // In case y hasn't been initialized yet } }
Vector CEnemy::GetDirection(Vector _targetpos){ if(Pos.x-_targetpos.x>WORLD_WIDTH/2){ _targetpos.x+=WORLD_WIDTH; }else if(Pos.x-_targetpos.x<-WORLD_WIDTH/2){ _targetpos.x-=WORLD_WIDTH; } if(Pos.y-_targetpos.y>WORLD_HEIGHT/2){ _targetpos.y+=WORLD_HEIGHT; }else if(Pos.y-_targetpos.y<-WORLD_HEIGHT/2){ _targetpos.y-=WORLD_HEIGHT; } Vector direction; direction.Set(_targetpos.x-Pos.x, _targetpos.y-Pos.y); direction.Multiple(1/direction.GetLength()); return direction; }
//-------------------------------------------------------------------------------------- Value* Vector::Clone() const { HRESULT hr; Vector* pNewVector = new Vector( Type(), Length() ); if( NULL == pNewVector ) return NULL; for( UINT i=0; i < Length(); i++ ) { hr = pNewVector->Set( i, Get(i) ); if( FAILED(hr) ) { // TODO - Error string SAFE_DELETE(pNewVector); return NULL; } } return pNewVector; }
void SumSymMatrix::MultVectorImpl(Number alpha, const Vector &x, Number beta, Vector &y) const { // A few sanity checks DBG_ASSERT(Dim()==x.Dim()); DBG_ASSERT(Dim()==y.Dim()); // Take care of the y part of the addition if( beta!=0.0 ) { y.Scal(beta); } else { y.Set(0.0); // In case y hasn't been initialized yet } for (Index iterm=0; iterm<NTerms(); iterm++) { DBG_ASSERT(IsValid(matrices_[iterm])); matrices_[iterm]->MultVector(alpha*factors_[iterm], x, 1.0, y); } }
void DiagMatrix::MultVectorImpl(Number alpha, const Vector &x, Number beta, Vector &y) const { // A few sanity checks DBG_ASSERT(Dim()==x.Dim()); DBG_ASSERT(Dim()==y.Dim()); DBG_ASSERT(IsValid(diag_)); // Take care of the y part of the addition if ( beta!=0.0 ) { y.Scal(beta); } else { y.Set(0.0); // In case y hasn't been initialized yet } SmartPtr<Vector> tmp_vec = y.MakeNew(); tmp_vec->Copy(x); tmp_vec->ElementWiseMultiply(*diag_); y.Axpy(alpha, *tmp_vec); }
// // Execute // U32 Guard::Execute(const U8 *data, Player &player) { const Data *d = (Data *) data; // Create an iterator for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++) { // Get the unit UnitObj *unit = **i; // Can it ever guard if (Tasks::UnitGuard::CanGuard(unit)) { switch (d->type) { case Target::OBJECT: { // Convert ID into a pointer if (MapObj *mapObj = Resolver::Object<MapObj, MapObjType>(d->object)) { IssueTask(d->mod, unit, new Tasks::UnitGuard(unit, Target(mapObj)), player); } break; } case Target::LOCATION: { Vector v; v.Set(d->location.x, d->location.y, d->location.z); IssueTask(d->mod, unit, new Tasks::UnitGuard(unit, Target(v)), player); break; } } } } return (sizeof (Data)); }
void GFXVertexList::RenormalizeNormals() { if (data.colors == 0 && data.vertices == 0) return; // if (numVertices > 0) { Vector firstNormal; if (changed&HAS_COLOR) firstNormal = data.colors[0].GetNormal(); else firstNormal = data.vertices[0].GetNormal(); float mag = firstNormal.Magnitude(); if (mag > GFX_SCALE/1.5 && mag < GFX_SCALE*1.5) return; if (mag < GFX_SCALE/100 && mag < .00001) firstNormal.Set( 1, 0, 0 ); firstNormal.Normalize(); if (changed&HAS_COLOR) data.colors[0].SetNormal( firstNormal ); else data.vertices[0].SetNormal( firstNormal ); if (changed&HAS_COLOR) { for (int i = 0; i < numVertices; i++) { //data.colors[i].SetNormal(data.colors[i].GetNormal().Normalize()); data.colors[i].i *= GFX_SCALE; data.colors[i].j *= GFX_SCALE; data.colors[i].k *= GFX_SCALE; } } else { for (int i = 0; i < numVertices; i++) { //data.vertices[i].SetNormal(data.vertices[i].GetNormal().Normalize()); data.vertices[i].i *= GFX_SCALE; data.vertices[i].j *= GFX_SCALE; data.vertices[i].k *= GFX_SCALE; } } } }
void CompoundSymMatrix::MultVectorImpl(Number alpha, const Vector &x, Number beta, Vector &y) const { if (!matrices_valid_) { matrices_valid_ = MatricesValid(); } DBG_ASSERT(matrices_valid_); // The vectors are assumed to be compound Vectors as well const CompoundVector* comp_x = dynamic_cast<const CompoundVector*>(&x); CompoundVector* comp_y = dynamic_cast<CompoundVector*>(&y); // A few sanity checks if (comp_x) { DBG_ASSERT(NComps_Dim()==comp_x->NComps()); } else { DBG_ASSERT(NComps_Dim() == 1); } if (comp_y) { DBG_ASSERT(NComps_Dim()==comp_y->NComps()); } else { DBG_ASSERT(NComps_Dim() == 1); } // Take care of the y part of the addition if( beta!=0.0 ) { y.Scal(beta); } else { y.Set(0.0); // In case y hasn't been initialized yet } for (Index irow=0; irow<NComps_Dim(); irow++) { SmartPtr<Vector> y_i; if (comp_y) { y_i = comp_y->GetCompNonConst(irow); } else { y_i = &y; } DBG_ASSERT(IsValid(y_i)); for (Index jcol=0; jcol<=irow; jcol++) { SmartPtr<const Vector> x_j; if (comp_x) { x_j = comp_x->GetComp(irow); } else { x_j = &x; } DBG_ASSERT(IsValid(x_j)); if (ConstComp(irow,jcol)) { ConstComp(irow,jcol)->MultVector(alpha, *comp_x->GetComp(jcol), 1., *comp_y->GetCompNonConst(irow)); } } for (Index jcol = irow+1; jcol < NComps_Dim(); jcol++) { if (ConstComp(jcol,irow)) { ConstComp(jcol,irow)->TransMultVector(alpha, *comp_x->GetComp(jcol), 1., *comp_y->GetCompNonConst(irow)); } } } }
void Camera::SetupView() { if (rect.Width() && rect.Height()) { halfHeight = ((F32) rect.Height()) * 0.5f; halfWidth = ((F32) rect.Width()) * 0.5f; aspectHW = halfHeight / halfWidth; if (!isIso) { projMatrix.SetProjection( nearPlane, farPlane * zoom, fov / zoom, aspectHW); if (Vid::renderState.status.clipVis) { halfHeight -= (F32) 64 * aspectHW; halfWidth -= (F32) 64; } aspectHW = halfHeight / halfWidth; invProjX = aspectHW / ( projMatrix.right.x * halfHeight); invProjY = 1 / (-projMatrix.up.y * halfHeight); } else { if (Vid::renderState.status.clipVis) { halfHeight -= (F32) 64 * aspectHW; halfWidth -= (F32) 64; } aspectHW = halfHeight / halfWidth; invProjX = 1 / ( projMatrix.right.x * halfHeight); invProjY = 1 / (-projMatrix.up.y * halfHeight); } invDepth = 1.0f / (farPlane - nearPlane); F32 proj23 = projMatrix.frontw == 0 ? 1 : projMatrix.frontw; invProjX *= proj23; invProjY *= proj23; #ifdef __DO_XMM_BUILD AllocXmm(); SetupXmm(); #endif F32 guard = (F32) Vid::renderState.clipGuardSize; // guard planes // F32 kx, ky, z = nearPlane; if (isIso) { kx = invProjX; ky = invProjY; } else { kx = (z * projMatrix.frontw + projMatrix.positw) * invProjX; ky = (z * projMatrix.frontw + projMatrix.positw) * invProjY; } frustrum[0].x = (-halfWidth - guard) * kx; frustrum[0].y = (-halfHeight - guard) * ky; frustrum[0].z = z; frustrum[1].x = ( halfWidth + guard) * kx; frustrum[1].y = frustrum[0].y; frustrum[1].z = z; frustrum[2].x = frustrum[1].x; frustrum[2].y = ( halfHeight + guard) * ky; frustrum[2].z = z; frustrum[3].x = frustrum[0].x; frustrum[3].y = frustrum[2].y; frustrum[3].z = z; z = farPlane * zoom; if (isIso) { kx = 1.0f * invProjX; ky = 1.0f * invProjY; } else { kx = (z * projMatrix.frontw + projMatrix.positw) * invProjX; ky = (z * projMatrix.frontw + projMatrix.positw) * invProjY; } frustrum[4].x = (-halfWidth - guard) * kx; frustrum[4].y = (-halfHeight - guard) * ky; frustrum[4].z = z; frustrum[5].x = ( halfWidth + guard) * kx; frustrum[5].y = frustrum[4].y; frustrum[5].z = z; frustrum[6].x = frustrum[5].x; frustrum[6].y = ( halfHeight + guard) * ky; frustrum[6].z = z; frustrum[7].x = frustrum[4].x; frustrum[7].y = frustrum[6].y; frustrum[7].z = z; Vector origin; origin.Set( 0.0, 0.0, 0.0); // near guardPlanes[0].Set( frustrum[0], frustrum[1], frustrum[2]); guardPlanes[0].Normalize(); // far guardPlanes[1].Set( frustrum[4], frustrum[5], frustrum[6]); guardPlanes[1].Normalize(); // left guardPlanes[2].Set( origin, frustrum[4], frustrum[7]); guardPlanes[2].Normalize(); // right guardPlanes[3].Set( origin, frustrum[5], frustrum[6]); guardPlanes[3].Normalize(); // top guardPlanes[4].Set( origin, frustrum[4], frustrum[5]); guardPlanes[4].Normalize(); // bottom guardPlanes[5].Set( origin, frustrum[6], frustrum[7]); guardPlanes[5].Normalize(); // fixup direction of plane equations U32 i; for (i = 0 ; i < 8; i++) { origin += frustrum[i]; } // all plane equation normals must point towards 'origin' // which is the center of all the frustrum points origin *= 0.125f; for (i = 0; i < 6 ; i++) { if (guardPlanes[i].Evalue( origin) < 0.0f) { // change sign of plane equation guardPlanes[i] *= -1.0f; } } // real planes // z = nearPlane; if (isIso) { kx = 1.0f * invProjX; ky = 1.0f * invProjY; } else { kx = (z * projMatrix.frontw + projMatrix.positw) * invProjX; ky = (z * projMatrix.frontw + projMatrix.positw) * invProjY; } frustrum[0].x = (-halfWidth) * kx; frustrum[0].y = (-halfHeight) * ky; frustrum[0].z = z; frustrum[1].x = ( halfWidth) * kx; frustrum[1].y = frustrum[0].y; frustrum[1].z = z; frustrum[2].x = frustrum[1].x; frustrum[2].y = ( halfHeight) * ky; frustrum[2].z = z; frustrum[3].x = frustrum[0].x; frustrum[3].y = frustrum[2].y; frustrum[3].z = z; z = farPlane * zoom; if (isIso) { kx = 1.0f * invProjX; ky = 1.0f * invProjY; } else { kx = (z * projMatrix.frontw + projMatrix.positw) * invProjX; ky = (z * projMatrix.frontw + projMatrix.positw) * invProjY; } frustrum[4].x = (-halfWidth) * kx; frustrum[4].y = (-halfHeight) * ky; frustrum[4].z = z; frustrum[5].x = ( halfWidth) * kx; frustrum[5].y = frustrum[4].y; frustrum[5].z = z; frustrum[6].x = frustrum[5].x; frustrum[6].y = ( halfHeight) * ky; frustrum[6].z = z; frustrum[7].x = frustrum[4].x; frustrum[7].y = frustrum[6].y; frustrum[7].z = z; origin.Set( 0.0, 0.0, 0.0); // near planes[0].Set( frustrum[0], frustrum[1], frustrum[2]); planes[0].Normalize(); // far planes[1].Set( frustrum[4], frustrum[5], frustrum[6]); planes[1].Normalize(); // left planes[2].Set( origin, frustrum[4], frustrum[7]); planes[2].Normalize(); // right planes[3].Set( origin, frustrum[5], frustrum[6]); planes[3].Normalize(); // top planes[4].Set( origin, frustrum[4], frustrum[5]); planes[4].Normalize(); // bottom planes[5].Set( origin, frustrum[6], frustrum[7]); planes[5].Normalize(); // fixup direction of plane equations for (i = 0 ; i < 8; i++) { origin += frustrum[i]; } // all plane equation normals must point towards 'origin' // which is the center of all the frustrum points origin *= 0.125f; for (i = 0; i < 6 ; i++) { if (planes[i].Evalue( origin) < 0.0f) { // change sign of plane equation planes[i] *= -1.0f; } } } if (Vid::curCamera == this) { Vid::SetCamera( *this, TRUE); } }
bool Game::StaticSphereCollisionDetection(Circle* circle1, Circle* circle2, ContactManifold* contactManifold) { // no check if both circles sleep if (circle1->getActive() == false && circle2->getActive() == false) return false; bool loop = false; Vector pos1 = circle1->GetPos(); Vector pos2 = circle2->GetPos(); float r1 = circle1->GetRadius(); float r2 = circle2->GetRadius(); float dist = pos1.distance(pos2); dist -= (r1 + r2); if(dist < 0.0f) { // set support var circle1->support++; circle2->support++; //// // many balls -> poss. that pos1==pos2 -> colNormal = NaN after normalization Vector colNormal = (pos1 - pos2).normalise(); Vector n1, n2; n1 = n2 = colNormal; Vector hitPoint = pos1 + circle1->GetRadius() * (pos1-pos2).normalise(); // Save the penetration value in the unused Z component hitPoint.Set(hitPoint.GetX(), hitPoint.GetY(), -dist); ManifoldPoint mpoint; mpoint.contactID1 = circle1; mpoint.contactID2 = circle2; mpoint.contactPoint = hitPoint; mpoint.responded = false; mpoint.impulse = 0.0f; mpoint.t_impulse = 0; mpoint.t = -1; mpoint.contactNormal = colNormal; contactManifold->Add(mpoint); circle1->setActive(true); circle2->setActive(true); return false; pos1 = pos1 - (n1 * dist * 1.1f); pos2 = pos2 + (n2 * dist * 1.1f); // critical section circle1->SetPos(pos1.GetX(), pos1.GetY()); circle2->SetPos(pos2.GetX(), pos2.GetY()); // critical section // make sure collided circles are awake circle1->setActive(true); circle2->setActive(true); loop = true; } return loop; }
// ========================= // Function called by CYTHON // ========================= int trk2dictionary( char* strTRKfilename, int Nx, int Ny, int Nz, float Px, float Py, float Pz, int n_count, int n_scalars, int n_properties, float fiber_shiftX, float fiber_shiftY, float fiber_shiftZ, int points_to_skip, float min_seg_len, float* ptrPEAKS, int Np, float vf_THR, int ECix, int ECiy, int ECiz, float* _ptrMASK, float* ptrTDI, char* path_out, int c ) { /*=========================*/ /* IC compartments */ /*=========================*/ float fiber[3][MAX_FIB_LEN]; float fiberNorm, fiberLen; unsigned int N, totICSegments = 0, totFibers = 0; unsigned char kept; Vector<double> P; std::string filename; std::string OUTPUT_path(path_out); std::map<segKey,float>::iterator it; std::map<segInVoxKey,float> FiberNorm; std::map<segInVoxKey,float>::iterator itNorm; segInVoxKey inVoxKey; printf( "\t* Exporting IC compartments:\n" ); FILE* fpTRK = fopen(strTRKfilename,"r+b"); if (fpTRK == NULL) return 0; fseek(fpTRK,1000,SEEK_SET); // set global variables dim.Set( Nx, Ny, Nz ); pixdim.Set( Px, Py, Pz ); nPointsToSkip = points_to_skip; fiberShiftXmm = fiber_shiftX * pixdim.x; // shift in mm for the coordinates fiberShiftYmm = fiber_shiftY * pixdim.y; fiberShiftZmm = fiber_shiftZ * pixdim.z; ptrMASK = _ptrMASK; doIntersect = c > 0; minSegLen = min_seg_len; // open files filename = OUTPUT_path+"/dictionary_TRK_norm.dict"; FILE* pDict_TRK_norm = fopen(filename.c_str(),"wb"); if ( !pDict_TRK_norm ) { printf( "\n[trk2dictionary] Unable to create output files" ); return 0; } filename = OUTPUT_path+"/dictionary_IC_f.dict"; FILE* pDict_IC_f = fopen(filename.c_str(),"wb"); filename = OUTPUT_path+"/dictionary_IC_vx.dict"; FILE* pDict_IC_vx = fopen(filename.c_str(),"wb"); filename = OUTPUT_path+"/dictionary_IC_vy.dict"; FILE* pDict_IC_vy = fopen(filename.c_str(),"wb"); filename = OUTPUT_path+"/dictionary_IC_vz.dict"; FILE* pDict_IC_vz = fopen(filename.c_str(),"wb"); filename = OUTPUT_path+"/dictionary_IC_ox.dict"; FILE* pDict_IC_ox = fopen(filename.c_str(),"wb"); filename = OUTPUT_path+"/dictionary_IC_oy.dict"; FILE* pDict_IC_oy = fopen(filename.c_str(),"wb"); filename = OUTPUT_path+"/dictionary_IC_len.dict"; FILE* pDict_IC_len = fopen(filename.c_str(),"wb"); filename = OUTPUT_path+"/dictionary_TRK_len.dict"; FILE* pDict_TRK_len = fopen(filename.c_str(),"wb"); filename = OUTPUT_path+"/dictionary_TRK_kept.dict"; FILE* pDict_TRK_kept = fopen(filename.c_str(),"wb"); // iterate over fibers ProgressBar PROGRESS( n_count ); PROGRESS.setPrefix("\t "); for(int f=0; f<n_count ;f++) { PROGRESS.inc(); N = read_fiber( fpTRK, fiber, n_scalars, n_properties ); fiberForwardModel( fiber, N ); kept = 0; if ( FiberSegments.size() > 0 ) { // add segments to files fiberNorm = 0; fiberLen = 0; for (it=FiberSegments.begin(); it!=FiberSegments.end(); it++) { fwrite( &totFibers, 4, 1, pDict_IC_f ); fwrite( &(it->first.x), 1, 1, pDict_IC_vx ); fwrite( &(it->first.y), 1, 1, pDict_IC_vy ); fwrite( &(it->first.z), 1, 1, pDict_IC_vz ); fwrite( &(it->first.ox), 1, 1, pDict_IC_ox ); fwrite( &(it->first.oy), 1, 1, pDict_IC_oy ); fwrite( &(it->second), 4, 1, pDict_IC_len ); ptrTDI[ it->first.z + dim.z * ( it->first.y + dim.y * it->first.x ) ] += it->second; inVoxKey.set( it->first.x, it->first.y, it->first.z ); FiberNorm[inVoxKey] += it->second; fiberLen += it->second; } for (itNorm=FiberNorm.begin(); itNorm!=FiberNorm.end(); itNorm++) { fiberNorm += pow(itNorm->second,2); } fiberNorm = sqrt(fiberNorm); FiberNorm.clear(); fwrite( &fiberNorm, 1, 4, pDict_TRK_norm ); // actual length considered in optimization fwrite( &fiberLen, 1, 4, pDict_TRK_len ); totICSegments += FiberSegments.size(); totFibers++; kept = 1; } fwrite( &kept, 1, 1, pDict_TRK_kept ); } PROGRESS.close(); fclose( fpTRK ); fclose( pDict_TRK_norm ); fclose( pDict_IC_f ); fclose( pDict_IC_vx ); fclose( pDict_IC_vy ); fclose( pDict_IC_vz ); fclose( pDict_IC_ox ); fclose( pDict_IC_oy ); fclose( pDict_IC_len ); fclose( pDict_TRK_len ); fclose( pDict_TRK_kept ); printf("\t [ %d fibers kept, %d segments in total ]\n", totFibers, totICSegments ); /*=========================*/ /* EC compartments */ /*=========================*/ unsigned int totECSegments = 0, totECVoxels = 0; printf( "\t* Exporting EC compartments:\n" ); filename = OUTPUT_path+"/dictionary_EC_vx.dict"; FILE* pDict_EC_vx = fopen( filename.c_str(), "wb" ); filename = OUTPUT_path+"/dictionary_EC_vy.dict"; FILE* pDict_EC_vy = fopen( filename.c_str(), "wb" ); filename = OUTPUT_path+"/dictionary_EC_vz.dict"; FILE* pDict_EC_vz = fopen( filename.c_str(), "wb" ); filename = OUTPUT_path+"/dictionary_EC_ox.dict"; FILE* pDict_EC_ox = fopen( filename.c_str(), "wb" ); filename = OUTPUT_path+"/dictionary_EC_oy.dict"; FILE* pDict_EC_oy = fopen( filename.c_str(), "wb" ); if ( ptrPEAKS != NULL ) { Vector<double> dir; double longitude, colatitude; segKey ec_seg; int ix, iy, iz, id, atLeastOne; float peakMax; float norms[ Np ]; float *ptr; PROGRESS.reset( dim.z ); for(iz=0; iz<dim.z ;iz++) { PROGRESS.inc(); for(iy=0; iy<dim.y ;iy++) for(ix=0; ix<dim.x ;ix++) { // check if in mask previously computed from IC segments if ( ptrTDI[ iz + dim.z * ( iy + dim.y * ix ) ] == 0 ) continue; peakMax = -1; for(id=0; id<Np ;id++) { ptr = ptrPEAKS + 3*(id + Np * ( iz + dim.z * ( iy + dim.y * ix ) )); dir.x = ptr[0]; dir.y = ptr[1]; dir.z = ptr[2]; norms[id] = dir.norm(); if ( norms[id] > peakMax ) peakMax = norms[id]; } if ( peakMax > 0 ) { ec_seg.x = ix; ec_seg.y = iy; ec_seg.z = iz; atLeastOne = 0; for(id=0; id<Np ;id++) { if ( norms[id]==0 || norms[id] < vf_THR*peakMax ) continue; // peak too small, don't consider it // store this orientation (invert axes if needed) ptr = ptrPEAKS + 3*(id + Np * ( iz + dim.z * ( iy + dim.y * ix ) )); dir.x = ECix * ptr[0]; dir.y = ECiy * ptr[1]; dir.z = ECiz * ptr[2]; if ( dir.y < 0 ) { // ensure to be in the right hemisphere (the one where kernels were pre-computed) dir.x = -dir.x; dir.y = -dir.y; dir.z = -dir.z; } colatitude = atan2( sqrt(dir.x*dir.x + dir.y*dir.y), dir.z ); longitude = atan2( dir.y, dir.x ); ec_seg.ox = (int)round(colatitude/M_PI*180.0); ec_seg.oy = (int)round(longitude/M_PI*180.0); fwrite( &ec_seg.x, 1, 1, pDict_EC_vx ); fwrite( &ec_seg.y, 1, 1, pDict_EC_vy ); fwrite( &ec_seg.z, 1, 1, pDict_EC_vz ); fwrite( &ec_seg.ox, 1, 1, pDict_EC_ox ); fwrite( &ec_seg.oy, 1, 1, pDict_EC_oy ); totECSegments++; atLeastOne = 1; } if ( atLeastOne>0 ) totECVoxels++; } } } PROGRESS.close(); } fclose( pDict_EC_vx ); fclose( pDict_EC_vy ); fclose( pDict_EC_vz ); fclose( pDict_EC_ox ); fclose( pDict_EC_oy ); printf("\t [ %d voxels, %d segments ]\n", totECVoxels, totECSegments ); return 1; }
// draw atom spheres and residue labels here bool Residue::Draw(const AtomSet *atomSet) const { if (!atomSet) { ERRORMSG("Residue::Draw(data) - NULL AtomSet*"); return false; } // verify presense of OpenGLRenderer if (!parentSet->renderer) { WARNINGMSG("Residue::Draw() - no renderer"); return false; } // get Molecule parent const Molecule *molecule; if (!GetParentOfType(&molecule)) return false; // get object parent const StructureObject *object; if (!GetParentOfType(&object)) return false; // is this residue labeled? const StyleSettings& settings = parentSet->styleManager->GetStyleForResidue(object, molecule->id, id); bool proteinLabel = (IsAminoAcid() && settings.proteinLabels.spacing > 0 && (id-1)%settings.proteinLabels.spacing == 0); bool nucleotideLabel = (IsNucleotide() && settings.nucleotideLabels.spacing > 0 && (id-1)%settings.nucleotideLabels.spacing == 0); bool overlayEnsembles = parentSet->showHideManager->OverlayConfEnsembles(); AtomStyle atomStyle; const AtomCoord *atom, *l1 = NULL, *l2 = NULL, *l3 = NULL; Vector labelColor; bool alphaVisible = false, alphaOnly = false; // iterate atoms; key is atomID AtomInfoMap::const_iterator a, ae = atomInfos.end(); for (a=atomInfos.begin(); a!=ae; ++a) { // get AtomCoord* for appropriate altConf AtomPntr ap(molecule->id, id, a->first); atom = atomSet->GetAtom(ap, overlayEnsembles, true); if (!atom) continue; // get Style if (!parentSet->styleManager->GetAtomStyle(this, ap, atom, &atomStyle)) return false; // highlight atom if necessary if (atomStyle.isHighlighted) atomStyle.color = GlobalColors()->Get(Colors::eHighlight); // draw the atom if (atomStyle.style != StyleManager::eNotDisplayed && atomStyle.radius > 0.0) parentSet->renderer->DrawAtom(atom->site, atomStyle); // store coords for positioning label, based on backbone coordinates if ((proteinLabel || nucleotideLabel) && a->second->classification != eSideChainAtom) { if (IsAminoAcid()) { if (a->second->name == " CA ") { l1 = atom; labelColor = atomStyle.color; alphaVisible = (atomStyle.style != StyleManager::eNotDisplayed); } else if (a->second->name == " C ") l2 = atom; else if (a->second->name == " N ") l3 = atom; } else if (IsNucleotide()) { if (a->second->name == " P ") { l1 = atom; labelColor = atomStyle.color; alphaVisible = (atomStyle.style != StyleManager::eNotDisplayed); } // labeling by alphas seems to work better for nucleotides // else if (a->second->name == " C4*") l2 = atom; // else if (a->second->name == " C5*") l3 = atom; } } } // if not all backbone atoms present (e.g. alpha only), use alpha coords of neighboring residues if (l1 && (!l2 || !l3)) { Molecule::ResidueMap::const_iterator prevRes, nextRes; const AtomCoord *prevAlpha, *nextAlpha; if ((prevRes=molecule->residues.find(id - 1)) != molecule->residues.end() && prevRes->second->alphaID != NO_ALPHA_ID && (prevAlpha=atomSet->GetAtom(AtomPntr(molecule->id, id - 1, prevRes->second->alphaID))) != NULL && (nextRes=molecule->residues.find(id + 1)) != molecule->residues.end() && nextRes->second->alphaID != NO_ALPHA_ID && (nextAlpha=atomSet->GetAtom(AtomPntr(molecule->id, id + 1, nextRes->second->alphaID))) != NULL) { l2 = prevAlpha; l3 = nextAlpha; alphaOnly = true; } } // draw residue (but not terminus) labels, assuming we have the necessary coordinates and // that alpha atoms are visible if (alphaVisible && (proteinLabel|| nucleotideLabel)) { Vector labelPosition; CNcbiOstrstream oss; double contrast = Colors::IsLightColor(settings.backgroundColor) ? 0 : 1; // protein label if (IsAminoAcid() && l1 && l2 && l3) { // position if (alphaOnly) { Vector forward = - ((l2->site - l1->site) + (l3->site - l1->site)); forward.normalize(); labelPosition = l1->site + 1.5 * forward; } else { Vector up = vector_cross(l2->site - l1->site, l3->site - l1->site); up.normalize(); Vector forward = (-((l2->site - l1->site) + (l3->site - l1->site)) / 2); forward.normalize(); labelPosition = l1->site + 1.5 * forward + 1.5 * up; } // text if (settings.proteinLabels.type == StyleSettings::eOneLetter) { oss << code; } else if (settings.proteinLabels.type == StyleSettings::eThreeLetter) { for (unsigned int i=0; i<nameGraph.size() && i<3; ++i) oss << ((i == 0) ? (char) toupper((unsigned char) nameGraph[0]) : (char) tolower((unsigned char) nameGraph[i])); } // add number if necessary if (settings.proteinLabels.numbering == StyleSettings::eSequentialNumbering) oss << ' ' << id; else if (settings.proteinLabels.numbering == StyleSettings::ePDBNumbering) oss << namePDB; // contrasting color? (default to CA's color) if (settings.proteinLabels.white) labelColor.Set(contrast, contrast, contrast); } // nucleotide label else if (IsNucleotide() && l2 && l3) { if (alphaOnly) { Vector forward = - ((l2->site - l1->site) + (l3->site - l1->site)); forward.normalize(); labelPosition = l1->site + 3 * forward; } else { labelPosition = l3->site + 3 * (l3->site - l2->site); } // text if (settings.nucleotideLabels.type == StyleSettings::eOneLetter) { oss << code; } else if (settings.nucleotideLabels.type == StyleSettings::eThreeLetter) { for (unsigned int i=0; i<3; ++i) if (nameGraph.size() > i && nameGraph[i] != ' ') oss << nameGraph[i]; } // add number if necessary if (settings.nucleotideLabels.numbering == StyleSettings::eSequentialNumbering) oss << ' ' << id; else if (settings.nucleotideLabels.numbering == StyleSettings::ePDBNumbering) oss << namePDB; // contrasting color? (default to C4*'s color) if (settings.nucleotideLabels.white) labelColor.Set(contrast, contrast, contrast); } // draw label if (oss.pcount() > 0) { string labelText = (string) CNcbiOstrstreamToString(oss); // apply highlight color if necessary if (GlobalMessenger()->IsHighlighted(molecule, id)) labelColor = GlobalColors()->Get(Colors::eHighlight); parentSet->renderer->DrawLabel(labelText, labelPosition, labelColor); } } return true; }
/** Compute the max-norm of the columns in the matrix. The result * is stored in cols_norms The vector is assumed to be initialized * of init is false. */ void ComputeColAMax(Vector& cols_norms, bool init=true) const { DBG_ASSERT(NCols() == cols_norms.Dim()); if (init) cols_norms.Set(0.); ComputeColAMaxImpl(cols_norms, init); }
/** Compute the max-norm of the rows in the matrix. The result is * stored in rows_norms. The vector is assumed to be initialized * of init is false. */ void ComputeRowAMax(Vector& rows_norms, bool init=true) const { DBG_ASSERT(NRows() == rows_norms.Dim()); if (init) rows_norms.Set(0.); ComputeRowAMaxImpl(rows_norms, init); }
/* HMBI code. Invoke as: hmbi <input file> [# of processors] The number of processors is optional, and the default is 1. To run in code in parallel, the source code must be compiled with -DPARALLEL, and MPI is required. */ main(int argc, char ** argv) { if (argc < 2) { printf("HMBI syntax:: hmbi <input file> [ # of processors (optional)]\n"); exit(1); } int nproc = 1; if (argc > 2) { string tmp = argv[2]; nproc = atoi(tmp.c_str()); } #ifdef PARALLEL int mynode=0,totalnodes; if (nproc > 1) { MPI_Init(&argc, &argv); MPI_Comm io_comm; MPI_File *fh, *fg; MPI_Info info; MPI_Comm_size(MPI_COMM_WORLD, &totalnodes); // get totalnodes MPI_Comm_rank(MPI_COMM_WORLD, &mynode); // get mynode if (mynode==0) printf("Running MPI parallel version with %d processors\n",nproc); } if (mynode == 0) { #endif /* PARALLEL */ // Set the number of processors Params::Parameters().SetNumberOfProcessors(nproc); // Store the primary process ID of the job. Used to create unique // scratch files int pid = getpid(); Params::Parameters().SetPID(pid); // Start wall clock timer time_t start_time, stop_time; start_time = time(NULL); // Open input file const int maxlength = 50; char filename[maxlength]; strcpy(filename, argv[1]); ifstream infile; infile.open(filename); assert(infile.is_open()); // Initialize Cluster object Cluster::cluster().Initialize(infile,nproc); printf("Cluster initialization complete\n"); if (! Params::Parameters().DoForces()) Params::Parameters().SetUseDLFind(false); // Compute the Energy (and forces, if requested) if (!Params::Parameters().UseDLFind()) { Cluster::cluster().RunJobsAndComputeEnergy(); } if ( Params::Parameters().PrintLevel() > 0) Cluster::cluster().ComputeDistanceMatrix(); // For debugging: Compute finite difference stress tensor bool do_finite_difference_stress_tensor = false; if (do_finite_difference_stress_tensor) { double delta = 0.001; // step size, in Angstroms Vector a1(3), a2(3), a3(3); // original unit cell vectors Vector new_a1(3),new_a2(3), new_a3(3); // deformed unit cell vectors Matrix Strain(3,3), Stress(3,3); Stress.Set(); // Grab original unit cell vectors a1 = Cluster::cluster().GetUnitCellVector(0); a2 = Cluster::cluster().GetUnitCellVector(1); a3 = Cluster::cluster().GetUnitCellVector(2); printf("Original lattice vectors (Ang):\n"); printf("a1 = (%f, %f, %f)\n",a1[0],a1[1],a1[2]); printf("a2 = (%f, %f, %f)\n",a2[0],a2[1],a2[2]); printf("a3 = (%f, %f, %f)\n",a3[0],a3[1],a3[2]); // Get cell volume, convert to Bohr^3 double V = Cluster::cluster().GetCellvolume() * AngToBohr * AngToBohr * AngToBohr; // Get the atomic coords. We use these when triggering the // reset of the dimer images, even though we don't change the atomic // positions at all. Vector Coords = Cluster::cluster().GetCurrentCoordinates(); // Loop over elements of the strain tensor e_ij for (int i=0;i<3;i++) { for (int j=0;j<3;j++) { // Set one element of the strain tensor to +delta printf("Setting Strain(%d,%d) to +%f\n",i,j,delta); Strain.Set(); new_a1.Set(); new_a2.Set(); new_a3.Set(); Strain(i,j) = delta; Strain.Print("Strain tensor"); // Deform the lattice vectors: new_ai = ai + Strain * ai new_a1 = Strain.MatrixTimesVector(a1); new_a1 += a1; new_a2 = Strain.MatrixTimesVector(a2); new_a2 += a2; new_a3 = Strain.MatrixTimesVector(a3); new_a3 += a3; printf("Updated lattice vectors (Ang):\n"); printf("a1 = (%f, %f, %f)\n",new_a1[0],new_a1[1],new_a1[2]); printf("a2 = (%f, %f, %f)\n",new_a2[0],new_a2[1],new_a2[2]); printf("a3 = (%f, %f, %f)\n",new_a3[0],new_a3[1],new_a3[2]); // Set the new lattice vectors and get the energy Cluster::cluster().SetUnitCellVectors(new_a1, new_a2, new_a3); Cluster::cluster().SetNewCoordinates(Coords); Cluster::cluster().RunJobsAndComputeEnergy(); double E1 = Cluster::cluster().GetHMBIEnergy(); // Repeat for strain tensor element -delta printf("Setting Strain(%d,%d) to -%f\n",i,j,delta); Strain.Set(); new_a1.Set(); new_a2.Set(); new_a3.Set(); Strain(i,j) = -delta; Strain.Print("Strain tensor"); // Deform the lattice vectors: new_ai = ai + Strain * ai new_a1 = Strain.MatrixTimesVector(a1); new_a1 += a1; new_a2 = Strain.MatrixTimesVector(a2); new_a2 += a2; new_a3 = Strain.MatrixTimesVector(a3); new_a3 += a3; printf("Updated lattice vectors (Ang):\n"); printf("a1 = (%f, %f, %f)\n",new_a1[0],new_a1[1],new_a1[2]); printf("a2 = (%f, %f, %f)\n",new_a2[0],new_a2[1],new_a2[2]); printf("a3 = (%f, %f, %f)\n",new_a3[0],new_a3[1],new_a3[2]); // Set the new lattice vectors and get the energy Cluster::cluster().SetUnitCellVectors(new_a1, new_a2, new_a3); Cluster::cluster().SetNewCoordinates(Coords); Cluster::cluster().RunJobsAndComputeEnergy(); double E2 = Cluster::cluster().GetHMBIEnergy(); // Final Stress tensor element stress(i,j) = 1/V dE/dstrain(i,j) Stress(i,j) = (1.0/V)*(E1 - E2)/(2*delta); } } printf("Finite Difference Stress Tensor:\n"); for (int i=0;i<3;i++) { printf("%15.9f %15.9f %15.9f\n",Stress(i,0), Stress(i,1), Stress(i,2)); } } // For debugging: Compute finite difference gradients bool do_finite_difference_grad = Params::Parameters().UseFiniteDifferenceGradients(); if (do_finite_difference_grad && Params::Parameters().DoForces()) { Vector Grad = Cluster::cluster().GetHMBIGradient(); Grad.Print("Analytical HMBI Gradient"); int Natoms = Cluster::cluster().GetTotalNumberOfAtoms(); Vector Eplus(3*Natoms), Eminus(3*Natoms); Vector Original_coords = Cluster::cluster().GetCurrentCoordinates(); Vector LatticeGradient(6); LatticeGradient.Set(); // Do the finite difference double delta = 0.001; // step size, in Angstroms /* for (int i=0;i<3*Natoms;i++) { printf("Shifting coord %d by -%f\n",i,delta); Vector Coords = Original_coords; Coords[i] -= delta; // Update the coordinates & get the energy Cluster::cluster().SetNewCoordinates(Coords); Cluster::cluster().RunJobsAndComputeEnergy(); Eplus[i] = Cluster::cluster().GetHMBIEnergy(); printf("Shifting coord %d by +%f\n",i,delta); Coords[i] += 2.0*delta; // Update the coordinates & get the energy Cluster::cluster().SetNewCoordinates(Coords); Cluster::cluster().RunJobsAndComputeEnergy(); Eminus[i] = Cluster::cluster().GetHMBIEnergy(); } */ // Now do finite difference over the lattice parameters, if appropriate double deltaTheta = 0.01; if (Params::Parameters().IsPeriodic() ) { string *params; params = new string[6]; params[0] = "a"; params[1] = "b"; params[2] = "c"; params[3] = "alpha", params[4] = "beta"; params[5] = "gamma"; Vector Coords = Original_coords; // we need these to trigger the reset of the // dimer images, even if we don't change the atomic positions at all. for (int i=0;i<6;i++) { double current = Cluster::cluster().GetUnitCellParameter(params[i]); double new1,new2; if (i < 3) { printf("Shifting coord %s by -%f\n",params[i].c_str(),delta); new1 = current - delta; } else { printf("Shifting coord %s by -%f\n",params[i].c_str(),deltaTheta); new1 = current - deltaTheta; } Cluster::cluster().SetUnitCellParameter(params[i],new1); Cluster::cluster().SetNewCoordinates(Coords); Cluster::cluster().RunJobsAndComputeEnergy(); double E1 = Cluster::cluster().GetHMBIEnergy(); if (i < 3) { printf("Shifting coord %s by +%f\n",params[i].c_str(),delta); new2 = current + delta; } else { printf("Shifting coord %s by +%f\n",params[i].c_str(),deltaTheta); new2 = current + deltaTheta; } // Update the coordinates & get the energy Cluster::cluster().SetUnitCellParameter(params[i],new2); Cluster::cluster().SetNewCoordinates(Coords); Cluster::cluster().RunJobsAndComputeEnergy(); double E2 = Cluster::cluster().GetHMBIEnergy(); if (i < 3) { LatticeGradient[i] = (E2 - E1) / ((new2 - new1)*AngToBohr); } else{ LatticeGradient[i] = (E2 - E1) / ((new2 - new1)*DegreesToRadians); } // Reset the lattice parameter to its original value Cluster::cluster().SetUnitCellParameter(params[i],current); } } // Form the actual gradient, G = (Eminus - Eplus)/(2*delta) Grad.Set(); Grad = Eminus; Grad -= Eplus; Grad.Scale(1.0/(2*delta*AngToBohr)); Grad.Print("Finite Difference HMBI Gradient"); LatticeGradient.Print("Finite Difference Lattice Parameter Gradient"); printf("*** Finished with finite difference."); exit(1); } // End finite difference debug code // Optimize geometry, if requested if ( Params::Parameters().DoForces() ) { if (Params::Parameters().UseDLFind()) { // Use DL-FIND for geometry optimization int Natoms = Cluster::cluster().GetTotalNumberOfAtoms(); int nvarin = 3*Natoms; int nvarin2 = 5*Natoms;// nframe*nat*3 + nweight + nmass + n_po_scaling int nspec = 2*Natoms; // nspec= nat + nz + 5*ncons + 2*nconn int master = 1; // work is done on the master node printf("Using DL-FIND for optimization\n"); dl_find_(&nvarin, &nvarin2, &nspec, &master); // Final energy printing doesn't work, because final //dlf_put_coords erases energies... double energy = Cluster::cluster().GetHMBIEnergy(); printf("HMBI Final Energy = %15.9f\n",energy); printf("\n"); Cluster::cluster().ComputeDistanceMatrix(); // Save a copy of the new geometry in a new input file. FILE *input; string input_file = "new_geom.in"; if ((input = fopen(input_file.c_str(),"w"))==NULL) { printf("OptimizeGeometry() : Cannot open file '%s'\n",input_file.c_str()); exit(1); } Cluster::cluster().PrintInputFile(input); printf("\nNew input file written to '%s'\n",input_file.c_str()); fclose(input); } else{ string type = "SteepestDescent"; //string type = "ConjugateGradients"; OptimizeGeometry(type ); } } if ( Params::Parameters().GetJobTypeStr() == "hessian" ) { printf("Computing finite difference Hessian\n"); fflush(stdout); Vector Original_coords = Cluster::cluster().GetCurrentCoordinates(); int imon = Params::Parameters().GetFrequencyForMonomer(); printf("Computing the vibrational frequencies for Monomer %d\n",imon); Matrix Hessian = GetFiniteDifferenceHessian(Original_coords,imon); Cluster::cluster().ComputeHarmonicFrequencies(Hessian); } infile.close(); if (Params::Parameters().CheckWarnings() > 0) { printf("\nHMBI job completed, but with %d warning(s).\n",Params::Parameters().CheckWarnings()); } else { printf("\nHMBI job succesful!!!\n"); } #ifdef PARALLEL // Tell all nodes to shut down if (nproc > 1) { MPI_Comm_size(MPI_COMM_WORLD, &totalnodes); // get totalnodes for (int rank = 1; rank < totalnodes; rank++) { MPI_Send(0, 0, MPI_INT, rank, DIETAG, MPI_COMM_WORLD); } } #endif /* PARALLEL */ // Stop the timer and print out the time stop_time = time(NULL); double elapsed_time = difftime(stop_time,start_time); printf("Total job wall time = %.0f seconds\n",elapsed_time); #ifdef PARALLEL } else { /* Slave node controller: just accept & run the jobs */ int MPI_PrintLevel = 0; MPI_Comm_size(MPI_COMM_WORLD, &totalnodes); // get totalnodes MPI_Comm_rank(MPI_COMM_WORLD, &mynode); // get mynode while (1) { char job[BUFFSIZE]; int success; MPI_Status status; while (1) { success = 0; // run the job MPI_Recv(&job,BUFFSIZE,MPI_CHAR,0,MPI_ANY_TAG,MPI_COMM_WORLD,&status); /* Check the tag of the received message. */ if (status.MPI_TAG == DIETAG) { //printf("%d: Received DIETAG\n",mynode); break; } else if (status.MPI_TAG == QCHEM_TAG) { if (MPI_PrintLevel > 0 ) printf("%d: Q-chem job: %s\n",mynode,job); } else if (status.MPI_TAG == TINKER_TAG) { if (MPI_PrintLevel > 0 ) printf("%d: Tinker job: %s\n",mynode,job); } else if (status.MPI_TAG == CAMCASP_TAG) { if (MPI_PrintLevel > 0 ) printf("%d: CamCasp job: %s\n",mynode,job); } else { printf("Unknown MPI tag\n"); } // Go ahead and run the job system(job); string jobstr = job; success = CheckIfJobSuccessful(jobstr,status.MPI_TAG); //MPI_Send(&success,1,MPI_INT,0,0,MPI_COMM_WORLD); MPI_Send(&success,1,MPI_INT,0,status.MPI_TAG,MPI_COMM_WORLD); } if (MPI_PrintLevel > 0 ) printf("MPI: Node %d exiting\n",mynode); break; } } // Finalize MPI and exit fflush(stdout); MPI_Finalize(); #endif /* PARALLEL */ }
void CompoundMatrix::MultVectorImpl(Number alpha, const Vector &x, Number beta, Vector &y) const { if (!matrices_valid_) { matrices_valid_ = MatricesValid(); } DBG_ASSERT(matrices_valid_); // The vectors are assumed to be compound Vectors as well const CompoundVector* comp_x = dynamic_cast<const CompoundVector*>(&x); CompoundVector* comp_y = dynamic_cast<CompoundVector*>(&y); #ifndef ALLOW_NESTED // A few sanity checks if (comp_x) { DBG_ASSERT(NComps_Cols()==comp_x->NComps()); } else { DBG_ASSERT(NComps_Cols() == 1); } if (comp_y) { DBG_ASSERT(NComps_Rows()==comp_y->NComps()); } else { DBG_ASSERT(NComps_Rows() == 1); } #endif if (comp_x) { if (NComps_Cols()!=comp_x->NComps()) { comp_x = NULL; } } if (comp_y) { if (NComps_Rows()!=comp_y->NComps()) { comp_y = NULL; } } // Take care of the y part of the addition if ( beta!=0.0 ) { y.Scal(beta); } else { y.Set(0.0); // In case y hasn't been initialized yet } for ( Index irow = 0; irow < NComps_Rows(); irow++ ) { SmartPtr<Vector> y_i; if (comp_y) { y_i = comp_y->GetCompNonConst(irow); } else { y_i = &y; } DBG_ASSERT(IsValid(y_i)); for ( Index jcol = 0; jcol < NComps_Cols(); jcol++ ) { if ( (owner_space_->Diagonal() && irow == jcol) || (!owner_space_->Diagonal() && ConstComp(irow,jcol)) ) { SmartPtr<const Vector> x_j; if (comp_x) { x_j = comp_x->GetComp(jcol); } else if (NComps_Cols() == 1) { x_j = &x; } DBG_ASSERT(IsValid(x_j)); ConstComp(irow, jcol)->MultVector(alpha, *x_j, 1., *y_i); } } } }
bool Unit::InsideCollideTree( Unit *smaller, QVector &bigpos, Vector &bigNormal, QVector &smallpos, Vector &smallNormal, bool bigasteroid, bool smallasteroid ) { if (smaller->colTrees == NULL || this->colTrees == NULL) return false; if (hull < 0) return false; if (smaller->colTrees->usingColTree() == false || this->colTrees->usingColTree() == false) return false; csOPCODECollider::ResetCollisionPairs(); Unit *bigger = this; csReversibleTransform bigtransform( bigger->cumulative_transformation_matrix ); csReversibleTransform smalltransform( smaller->cumulative_transformation_matrix ); smalltransform.SetO2TTranslation( csVector3( smaller->cumulative_transformation_matrix.p -bigger->cumulative_transformation_matrix.p ) ); bigtransform.SetO2TTranslation( csVector3( 0, 0, 0 ) ); //we're only gonna lerp the positions for speed here... gahh! // Check for shield collisions here prior to checking for mesh on mesh or ray collisions below. csOPCODECollider *tmpCol = smaller->colTrees->colTree( smaller, bigger->GetWarpVelocity() ); if ( tmpCol && ( tmpCol->Collide( *bigger->colTrees->colTree( bigger, smaller->GetWarpVelocity() ), &smalltransform, &bigtransform ) ) ) { csCollisionPair *mycollide = csOPCODECollider::GetCollisions(); unsigned int numHits = csOPCODECollider::GetCollisionPairCount(); if (numHits) { smallpos.Set( (mycollide[0].a1.x+mycollide[0].b1.x+mycollide[0].c1.x)/3.0f, (mycollide[0].a1.y+mycollide[0].b1.y+mycollide[0].c1.y)/3.0f, (mycollide[0].a1.z+mycollide[0].b1.z+mycollide[0].c1.z)/3.0f ); smallpos = Transform( smaller->cumulative_transformation_matrix, smallpos ); bigpos.Set( (mycollide[0].a2.x+mycollide[0].b2.x+mycollide[0].c2.x)/3.0f, (mycollide[0].a2.y+mycollide[0].b2.y+mycollide[0].c2.y)/3.0f, (mycollide[0].a2.z+mycollide[0].b2.z+mycollide[0].c2.z)/3.0f ); bigpos = Transform( bigger->cumulative_transformation_matrix, bigpos ); csVector3 sn, bn; sn.Cross( mycollide[0].b1-mycollide[0].a1, mycollide[0].c1-mycollide[0].a1 ); bn.Cross( mycollide[0].b2-mycollide[0].a2, mycollide[0].c2-mycollide[0].a2 ); sn.Normalize(); bn.Normalize(); smallNormal.Set( sn.x, sn.y, sn.z ); bigNormal.Set( bn.x, bn.y, bn.z ); smallNormal = TransformNormal( smaller->cumulative_transformation_matrix, smallNormal ); bigNormal = TransformNormal( bigger->cumulative_transformation_matrix, bigNormal ); return true; } } un_iter i; static float rsizelim = XMLSupport::parse_float( vs_config->getVariable( "physics", "smallest_subunit_to_collide", ".2" ) ); clsptr bigtype = bigasteroid ? ASTEROIDPTR : bigger->isUnit(); clsptr smalltype = smallasteroid ? ASTEROIDPTR : smaller->isUnit(); if ( bigger->SubUnits.empty() == false && (bigger->graphicOptions.RecurseIntoSubUnitsOnCollision == true || bigtype == ASTEROIDPTR) ) { i = bigger->getSubUnits(); float rad = smaller->rSize(); for (Unit *un; (un = *i); ++i) { float subrad = un->rSize(); if ( (bigtype != ASTEROIDPTR) && (subrad/bigger->rSize() < rsizelim) ) { break; } if ( ( un->Position()-smaller->Position() ).Magnitude() <= subrad+rad ) { if ( ( un->InsideCollideTree( smaller, bigpos, bigNormal, smallpos, smallNormal, bigtype == ASTEROIDPTR, smalltype == ASTEROIDPTR ) ) ) return true; } } } if ( smaller->SubUnits.empty() == false && (smaller->graphicOptions.RecurseIntoSubUnitsOnCollision == true || smalltype == ASTEROIDPTR) ) { i = smaller->getSubUnits(); float rad = bigger->rSize(); for (Unit *un; (un = *i); ++i) { float subrad = un->rSize(); if ( (smalltype != ASTEROIDPTR) && (subrad/smaller->rSize() < rsizelim) ) break; if ( ( un->Position()-bigger->Position() ).Magnitude() <= subrad+rad ) { if ( ( bigger->InsideCollideTree( un, bigpos, bigNormal, smallpos, smallNormal, bigtype == ASTEROIDPTR, smalltype == ASTEROIDPTR ) ) ) return true; } } } //FIXME //doesn't check all i*j options of subunits vs subunits return false; }
/* * Class: org_upp_AndroidMath_Vector * Method: set * Signature: (IF)V */ JNIEXPORT void JNICALL Java_org_upp_AndroidMath_Vector_set (JNIEnv *env, jobject obj, jint id, jfloat value) { Vector* vec = mm.Get(env, obj); vec->Set(id, value); }