int main(int argc,char* argv[]) { const char* keys = "{ s | scale | 1 | scale of video input }" "{ r | record | false | record frames }" "{ v | video | 0 | video input }"; cv::CommandLineParser cmd(argc,argv,keys); std::string videoName = cmd.get<std::string>("v"); bool recordVideo = cmd.get<bool>("r"); cv::Ptr<cv::VideoCapture> capture = new cv::VideoCapture(); if (videoName.length() == 1) { capture->open(::atoi(videoName.c_str())); } else { capture->open(videoName); } if (!capture->isOpened()) return -1; bool done(false); cv::Mat frame,gray; // please comment in and out -- this is causing the problem int someRandomNumber(0); DenseOpticalFlow dof(cmd.get<double>("s")); do { if (capture->read(frame)) { cv::cvtColor(frame,gray,cv::COLOR_BGR2GRAY); dof(gray,recordVideo); } else { done = true; } int k = (int)cv::waitKey(1); if (27 == k) done = true; } while (!done); return 0; }
int main() { long T; int n, i, j, q, p; char st[55], c; bool f; scanf("%ld", &T); while (T--) { for (i = 0; i < 1005; i++) { for (j = 0; j <= 26; j++) { tire[i].n[j] = -1; } tire[i].f = 0; tire[i].d = -1; tire[i].b = false; } scanf("%d", &n); p = 0; for (i = 0; i < n; i++) { scanf("%s", st); q = 0; for (j = 0; j < strlen(st); j++) { if (st[j] >= 'a' && st[j] <= 'z') { if (tire[q].n[st[j] - 'a'] < 0) { tire[q].n[st[j] - 'a'] = ++p; tire[p].d = st[j] - 'a'; tire[p].fa = q; } q = tire[q].n[st[j] - 'a']; } } tire[q].b = true; } getchar(); dof(); q = 0; f = true; while (true) { c = getchar(); if (c == '\n' || c == EOF) { break; } q = getnext(q, c - 'a'); if (tire[q].b) { f = false; } } if (f) { printf("not infected\n"); }else{ printf("infected\n"); } } }
bool CompliantGraspCopyTask::compliantCopy(const db_planner::Grasp *grasp, Pr2Gripper2010::ComplianceType compliance) { //open slowly (2 degrees increments) //also, positive change means open for the pr2 gripper double OPEN_BY = 0.035; Pr2Gripper2010 *gripper = static_cast<Pr2Gripper2010 *>(mHand); gripper->setCompliance(compliance); std::vector<double> dof(mHand->getNumDOF(), 0.0); std::vector<double> stepSize(mHand->getNumDOF(), M_PI / 36.0); mHand->getDOFVals(&dof[0]); bool done = false; transf lastTran = mHand->getTran(); while (!done) { //DBGA("Move loop"); //open the hand a little bit for (int d = 0; d < mHand->getNumDOF(); d++) { dof[d] += OPEN_BY; } mHand->checkSetDOFVals(&dof[0]); mHand->moveDOFToContacts(&dof[0], &stepSize[0], true, false); //if we are far enough from the last saved grasp, go ahead and save a new one transf currentTran = mHand->getTran(); if (!similarity(currentTran, lastTran)) { //save the grasp DBGA("Storing a compliant copy"); //compliance messes up the pre-grasp computation gripper->setCompliance(Pr2Gripper2010::NONE); if (!checkStoreGrasp(grasp)) { return false; } gripper->setCompliance(compliance); //remember the last saved grasp lastTran = currentTran; } //if we have not opened as much as we wanted to, we've hit something; we are done for (int d = 0; d < mHand->getNumDOF(); d++) { if (fabs(mHand->getDOF(d)->getVal() - dof[d]) > 1.0e-5 || dof[d] == mHand->getDOF(d)->getMin() || dof[d] == mHand->getDOF(d)->getMax()) { //DBGA("Done moving"); done = true; break; } } } return true; }
void MatlabAdapter::initGenCoords() { engEvalString(mEngine, "coordNames = {Model.GenCoor.Name}"); engEvalString(mEngine, "coordRanges = [ Model.lb; Model.ub]"); mxArray *mxNames = engGetVariable(mEngine, "coordNames"); mxArray *mxRanges = engGetVariable(mEngine, "coordRanges"); double* values = mxGetPr(mxRanges); double min, max, stepSize; unsigned size = tree.dofs.size(); for(unsigned i=0; i < size; i++) { mxArray *mxCell = mxGetCell(mxNames, i); char* name = mxArrayToString(mxCell); min = values[i]; max = values[i+size]; stepSize = (max-min) / 100.0; if(stepSize > 0.05) stepSize = 0.05; DegreeOfFreedom dof(min, max, 0, stepSize); dof.name = name; if(dof.name.size() > 6) { if(dof.name.substr(0,6).compare("root_r") == 0) { TRACE("limited"); dof.rangeType = DegreeOfFreedom::limitedRange; dof.min = -5; dof.max = 5; } else { TRACE("circular"); dof.rangeType = DegreeOfFreedom::circularRange; dof.min = - M_PI; dof.max = + M_PI; } } tree.dofs.at(i)=dof; TRACE("generalized coordinat %s @ %i : min %f to %f", name, i, min, max); } mxDestroyArray(mxNames); mxDestroyArray(mxRanges); }
int main() { int c; unsigned long long a[4], y; fscanf(stdin, "%d", &c); while (c--) { fprintf(stdout, "%d: ", c); fscanf(stdin, "%lld%lld%lld%lld%lld", &y, &(a[0]), &(a[1]), &(a[2]), &(a[3])); fprintf(stdout, "%lld\n", dof(y, a)); } return 0; }
//********************************************************************** PHX_EVALUATE_FIELDS(WeakDirichletResidual,workset) { for (index_t cell = 0; cell < workset.num_cells; ++cell) { for (std::size_t ip = 0; ip < num_ip; ++ip) { normal_dot_flux_plus_pen(cell,ip) = ScalarT(0.0); for (std::size_t dim = 0; dim < num_dim; ++dim) { normal_dot_flux_plus_pen(cell,ip) += normal(cell,ip,dim) * flux(cell,ip,dim); } normal_dot_flux_plus_pen(cell,ip) += sigma(cell,ip) * (dof(cell,ip) - value(cell,ip)); } } if(workset.num_cells>0) Intrepid2::FunctionSpaceTools:: integrate<ScalarT>(residual, normal_dot_flux_plus_pen, (this->wda(workset).bases[basis_index])->weighted_basis_scalar, Intrepid2::COMP_CPP); }
void CVX_External::setFixed(bool xTranslate, bool yTranslate, bool zTranslate, bool xRotate, bool yRotate, bool zRotate) { dofFixed = dof(xTranslate, yTranslate, zTranslate, xRotate, yRotate, zRotate); extTranslation = extRotation = Vec3D<double>(); //clear displacements }
void fourier_harmonic_3D(std::vector<Real> harmonics, Real lc, Real R, std::string output_name,int verbose){ ////=============================================================//// ////======================= Mesh building =====================//// ////=============================================================//// if (verbose>0){ std::cout<<"Construction du maillage"<<std::endl; } gmsh_sphere(("sphere_"+NbrToStr(lc)).c_str(),R,lc,verbose); ////=============================================================//// ////======================= Mesh loading ======================//// ////=============================================================//// if (verbose>0){ std::cout<<"Chargement du maillage"<<std::endl; } Real kappa=1.; geometry geom; load_node_gmsh(geom,("sphere_"+NbrToStr(lc)).c_str()); mesh_2D Omega(geom); load_elt_gmsh(Omega,0); //gmsh_clean(("sphere_"+NbrToStr(lc)).c_str()); ////=============================================================//// ////================== Calcul de la normale =====================//// ////=============================================================//// nrml_2D n_(Omega); ////=============================================================//// ////================ Assemblage de la matrice ===================//// ////=============================================================//// if (verbose>0){ std::cout<<"Assemblage operateurs integraux"<<std::endl; } int nbelt = nb_elt(Omega); P1_2D dof(Omega); int nbdof = nb_dof(dof); if (verbose>0){ std::cout<<"Matrice de taille: "; std::cout<<nbdof<< std::endl; std::cout<<"Nel: "; std::cout<<nbelt<< std::endl; } gmm_dense V(nbdof,nbdof),W(nbdof,nbdof),K(nbdof,nbdof),M(nbdof,nbdof); bem<P1_2D,P1_2D, SLP_3D> Vop (kappa,n_,n_); bem<P1_2D,P1_2D, HSP_3D> Wop (kappa,n_,n_); bem<P1_2D,P1_2D, DLP_3D> Kop (kappa,n_,n_); progress bar("assembly", nbelt*nbelt,verbose); for(int j=0; j<nbelt; j++){ const elt_2D& tj = Omega[j]; const N3& jj = dof[j]; for(int k=0; k<nbelt; k++,bar++){ const elt_2D& tk = Omega[k]; const N3& kk = dof[k]; V (jj,kk) += Vop (tj,tk); W (jj,kk) += Wop (tj,tk); K (jj,kk) += Kop (tj,tk); } M(jj,jj) += MassP1(tj); } bar.end(); // for (int l=0;l<harmonics.size();l++){ // Real p = harmonics[l]; // ////=============================================================//// // ////================== Harmonique de Fourier ====================//// // ////=============================================================//// // vect<Cplx> Ep;resize(Ep,nbdof);fill(Ep,0.); // for (int j=0 ; j<nbelt ; j++){ // const elt_2D& seg = Omega[j]; // const N3& I = dof[j]; // R3 X0; X0[0] = seg[0][0];X0[1]=seg[0][1]; X0[2]=seg[0][2]; // R3 X1; X1[0] = seg[1][0];X1[1]=seg[1][1]; X1[2]=seg[1][2]; // R3 X2; X2[0] = seg[2][0];X2[1]=seg[2][1]; X2[2]=seg[2][2]; // Real phi0 = atan2(X0[1],X0[0]); // Real phi1 = atan2(X1[1],X1[0]); // Real phi2 = atan2(X2[1],X2[0]); // Real theta0 = acos(X0[2]); // Real theta1 = acos(X1[2]); // Real theta2 = acos(X2[2]); // if (phi0<0){ // phi0 += 2 * M_PI; // } // if (phi1<0){ // phi1 += 2 * M_PI; // } // if (phi2<0){ // phi2 += 2 * M_PI; // } // C3 Vinc; // Vinc[0] = boost::math::spherical_harmonic(p,p,theta0,phi0); // Vinc[1] = boost::math::spherical_harmonic(p,p,theta1,phi1); // Vinc[2] = boost::math::spherical_harmonic(p,p,theta2,phi2); // Ep[I] = Vinc; // } // vect<Cplx> Eph;resize(Eph,nbdof);fill(Eph,0.); // mv_prod(Eph,M,Ep); // ////=============================================================//// // ////================== Calcul valeurs propres ===================//// // ////=============================================================//// // ////===================================//// // ////===== Test avec orthogonalité =====//// // Cplx val =0; // Cplx err =0; // for(int j=0; j<nbdof; j++){ // val += Ep[j]*conj(Eph[j]); // } // err = abs(val)-1; // std::cout<<"PS : "<<err<<std::endl; // ////===================================//// // ////=========== Test avec V ===========//// // val =0; // Real err_V =0; // Cplx j_p = boost::math::sph_bessel(p, kappa*R); // Cplx y_p = boost::math::sph_neumann(p, kappa*R); // Cplx h_p = boost::math::sph_hankel_1(p, kappa*R); // Cplx j_p_prime = boost::math::sph_bessel_prime(p, kappa*R); // Cplx y_p_prime = boost::math::sph_neumann_prime(p, kappa*R); // Cplx h_p_prime = j_p_prime + iu * y_p_prime; // Cplx ref = iu * kappa * j_p * h_p; // vect<Cplx> Temp;resize(Temp,nbdof);fill(Temp,0.); // mv_prod(Temp,V,Ep); // for(int j=0; j<nbdof; j++){ // val += conj(Ep[j])*Temp[j]; // } // // // err_V = abs(val-ref) /abs(ref); // if (verbose>0){ // std::cout<<"V : "<<err_V<<std::endl; // } // ////===================================//// // ////=========== Test avec W ===========//// // val =0; // Real err_W =0; // ref = - iu * pow(kappa,3) * j_p_prime * h_p_prime; // fill(Temp,0.); // mv_prod(Temp,W,Ep); // for(int j=0; j<nbdof; j++){ // val += conj(Ep[j])*Temp[j]; // } // err_W = abs(val-ref) /abs(ref); // if (verbose>0){ // std::cout<<"W : "<<err_W<<std::endl; // } // ////===================================//// // ////=========== Test avec K ===========//// // val =0; // Real err_K =0; // ref = iu /2. * kappa*kappa * (j_p_prime * h_p + j_p * h_p_prime); // fill(Temp,0.); // mv_prod(Temp,K,Ep); // for(int j=0; j<nbdof; j++){ // val += conj(Ep[j])*Temp[j]; // } // err_K = abs(val-ref) /abs(ref); // if (verbose>0){ // std::cout<<"K : "<<err_K<<std::endl; // } // ////=============================================================//// // ////======================== Sauvegardes ========================//// // ////=============================================================//// // std::ofstream output((output_name+"_"+NbrToStr<Real>(p)+".txt").c_str(),std::ios::app); // if (!output){ // std::cerr<<"Output file cannot be created"<<std::endl; // exit(1); // } // else{ // output<<lc<<" "<<err_V<<" "<<err_W<<" "<<err_K<<std::endl; // } // output.close(); // if (l == 0) // { // std::cout << p << "P" << std::endl; // } // } }
void gamlr(int *famid, // 1 gaus, 2 bin, 3 pois int *n_in, // nobs int *p_in, // nvar int *N_in, // length of nonzero x entries int *xi_in, // length-l row ids for nonzero x int *xp_in, // length-p+1 pointers to each column start double *xv_in, // nonzero x entry values double *y_in, // length-n y int *prexx, // indicator for pre-calc xx double *xxv_in, // dense columns of upper tri for xx double *eta, // length-n fixed shifts (assumed zero for gaussian) double *varweight, // length-p weights double *obsweight, // length-n weights int *standardize, // whether to scale penalty by sd(x_j) int *nlam, // length of the path double *delta, // path stepsize double *penscale, // gamma in the GL paper double *thresh, // cd convergence int *maxit, // cd max iterations double *lambda, // output lambda double *deviance, // output deviance double *df, // output df double *alpha, // output intercepts double *beta, // output coefficients int *exits, // exit status. 0 is normal int *verb) // talk? { dirty = 1; // flag to say the function has been called // time stamp for periodic R interaction time_t itime = time(NULL); /** Build global variables **/ fam = *famid; n = *n_in; p = *p_in; nd = (double) n; pd = (double) p; N = *N_in; W = varweight; V = obsweight; E = eta; Y = y_in; xi = xi_in; xp = xp_in; xv = xv_in; doxx = *prexx; xxv = xxv_in; H = new_dvec(p); checkdata(*standardize); A=0.0; B = new_dzero(p); G = new_dzero(p); ag0 = new_dzero(p); gam = *penscale; npass = itertotal = 0; // some local variables double Lold, NLLHD, Lsat; int s; // family dependent settings switch( fam ) { case 2: nllhd = &bin_nllhd; reweight = &bin_reweight; A = log(ybar/(1-ybar)); Lsat = 0.0; break; case 3: nllhd = &po_nllhd; reweight = &po_reweight; A = log(ybar); // nonzero saturated deviance Lsat = ysum; for(int i=0; i<n; i++) if(Y[i]!=0) Lsat += -Y[i]*log(Y[i]); break; default: fam = 1; // if it wasn't already nllhd = &lin_nllhd; A = (ysum - sum_dvec(eta,n))/nd; Lsat=0.0; } if(fam!=1){ Z = new_dvec(n); vxbar = new_dvec(p); vxz = new_dvec(p); } else{ Z = Y; vxz = new_dzero(p); if(V[0]!=0){ vxbar = new_dvec(p); vstats(); } else{ vxbar = xbar; vsum = nd; for(int j=0; j<p; j++) for(int i=xp[j]; i<xp[j+1]; i++) vxz[j] += xv[i]*Z[xi[i]]; } } l1pen = INFINITY; Lold = INFINITY; NLLHD = nllhd(n, A, E, Y); if(*verb) speak("*** n=%d observations and p=%d covariates ***\n", n,p); // move along the path for(s=0; s<*nlam; s++){ // deflate the penalty if(s>0) lambda[s] = lambda[s-1]*(*delta); l1pen = lambda[s]*nd; // run descent exits[s] = cdsolve(*thresh,*maxit); // update parameters and objective itertotal += npass; Lold = NLLHD; NLLHD = nllhd(n, A, E, Y); deviance[s] = 2.0*(NLLHD - Lsat); df[s] = dof(s, lambda, NLLHD); alpha[s] = A; copy_dvec(&beta[s*p],B,p); if(s==0) *thresh *= deviance[0]; // relativism // gamma lasso updating for(int j=0; j<p; j++) if(isfinite(gam)){ if( (W[j]>0.0) & isfinite(W[j]) ) W[j] = 1.0/(1.0+gam*fabs(B[j])); } else if(B[j]!=0.0){ W[j] = 0.0; } // verbalize if(*verb) speak("segment %d: lambda = %.4g, dev = %.4g, npass = %d\n", s+1, lambda[s], deviance[s], npass); // exit checks if(deviance[s]<0.0){ exits[s] = 1; shout("Warning: negative deviance. "); } if(df[s] >= nd){ exits[s] = 1; shout("Warning: saturated model. "); } if(exits[s]){ shout("Finishing path early.\n"); *nlam = s; break; } itime = interact(itime); } *maxit = itertotal; gamlr_cleanup(); }
//********************************************************************** PHX_EVALUATE_FIELDS(DirichletResidual,workset) { for (std::size_t i = 0; i < workset.num_cells; ++i) for (std::size_t j = 0; j < cell_data_size; ++j) residual(i,j)=dof(i,j)-value(i,j); }
/* ************************************************************************** */ void Pose2MobileVetLinArm::forwardKinematics(const Pose2Vector& p, boost::optional<const gtsam::Vector&> v, std::vector<gtsam::Pose3>& px, boost::optional<std::vector<gtsam::Vector3>&> vx, boost::optional<std::vector<gtsam::Matrix>&> J_px_p, boost::optional<std::vector<gtsam::Matrix>&> J_vx_p, boost::optional<std::vector<gtsam::Matrix>&> J_vx_v) const { if (v) throw runtime_error("[Pose2MobileArm] TODO: velocity not implemented"); if (!v && (vx || J_vx_p || J_vx_v)) throw runtime_error("[Pose2MobileArm] ERROR: only ask for velocity in workspace given velocity in " "configuration space"); // space for output px.resize(nr_links()); if (vx) vx->resize(nr_links()); if (J_px_p) J_px_p->assign(nr_links(), Matrix::Zero(6, dof())); if (J_vx_p) J_vx_p->assign(nr_links(), Matrix::Zero(3, dof())); if (J_vx_v) J_vx_v->assign(nr_links(), Matrix::Zero(3, dof())); // vehicle & arm base pose Pose3 veh_base, tso_base, arm_base; Matrix63 Hveh_base; Matrix64 Htso_base, Harm_base; if (J_px_p || J_vx_p || J_vx_v) { veh_base = computeBasePose3(p.pose(), Hveh_base); tso_base = liftBasePose3(p.pose(), p.configuration()(0), base_T_torso_, reverse_linact_, Htso_base); Matrix6 H_tso_comp; arm_base = tso_base.compose(torso_T_arm_, H_tso_comp); Harm_base = H_tso_comp * Htso_base; } else { veh_base = computeBasePose3(p.pose()); tso_base = liftBasePose3(p.pose(), p.configuration()(0), base_T_torso_, reverse_linact_); arm_base = tso_base.compose(torso_T_arm_); } // veh base link px[0] = veh_base; if (J_px_p) (*J_px_p)[0].block<6,3>(0,0) = Hveh_base; // torso link px[1] = tso_base; if (J_px_p) (*J_px_p)[1].block<6,4>(0,0) = Htso_base; // arm links vector<Pose3> armjpx; vector<Matrix> Jarm_jpx_jp; arm_.updateBasePose(arm_base); arm_.forwardKinematics(p.configuration().tail(arm_.dof()), boost::none, armjpx, boost::none, J_px_p ? boost::optional<vector<Matrix>&>(Jarm_jpx_jp) : boost::none); for (size_t i = 0; i < arm_.dof(); i++) { px[i+2] = armjpx[i]; if (J_px_p) { // see compose's jacobian (*J_px_p)[i+2].block<6,4>(0,0) = (armjpx[i].inverse() * arm_base).AdjointMap() * Harm_base; (*J_px_p)[i+2].block(0,4,6,arm_.dof()) = Jarm_jpx_jp[i]; } } }
/* ************************************************************************** */ void Pose2MobileArm::forwardKinematics( const Pose2Vector& p, boost::optional<const gtsam::Vector&> v, std::vector<gtsam::Pose3>& px, boost::optional<std::vector<gtsam::Vector3>&> vx, boost::optional<std::vector<gtsam::Matrix>&> J_px_p, boost::optional<std::vector<gtsam::Matrix>&> J_vx_p, boost::optional<std::vector<gtsam::Matrix>&> J_vx_v) const { if (v) throw runtime_error("[Pose2MobileArm] TODO: velocity not implemented"); if (!v && (vx || J_vx_p || J_vx_v)) throw runtime_error("[Pose2MobileArm] ERROR: only ask for velocity in workspace given velocity in " "configuration space"); // space for output px.resize(nr_links()); if (vx) vx->resize(nr_links()); if (J_px_p) J_px_p->assign(nr_links(), Matrix::Zero(6, dof())); if (J_vx_p) J_vx_p->assign(nr_links(), Matrix::Zero(3, dof())); if (J_vx_v) J_vx_v->assign(nr_links(), Matrix::Zero(3, dof())); // vehicle & arm base pose Pose3 veh_base, arm_base; Matrix63 Hveh_base, Harm_base; if (J_px_p || J_vx_p || J_vx_v) { veh_base = computeBasePose3(p.pose(), Hveh_base); arm_base = computeBaseTransPose3(p.pose(), base_T_arm_, Harm_base); } else { veh_base = computeBasePose3(p.pose()); arm_base = computeBaseTransPose3(p.pose(), base_T_arm_); } // call arm pose and velocity, for arm links // px[0] = base_pose3; px[i] = arm_base * px_arm[i-1] // vx[0] = v(0:1,0); vx[i] = vx[0] + angular x arm_base_pos + arm_base_rot * vx_arm[i-1] // veh base link px[0] = veh_base; if (J_px_p) (*J_px_p)[0].block<6,3>(0,0) = Hveh_base; if (vx) { (*vx)[0] = Vector3((*v)[0], (*v)[1], 0.0); // (*J_vx_p)[0] is zero if (J_vx_v) (*J_vx_v)[0].block<2,2>(0,0) = Matrix2::Identity(); } // arm links vector<Pose3> armjpx; vector<Vector3> armjvx; vector<Matrix> Jarm_jpx_jp, Jarm_jvx_jp, Jarm_jvx_jv; arm_.updateBasePose(arm_base); if (v) { const Vector varm = v->tail(arm_.dof()); arm_.forwardKinematics(p.configuration(), boost::optional<const Vector&>(varm), armjpx, vx ? boost::optional<vector<Vector3>&>(armjvx) : boost::none, J_px_p ? boost::optional<vector<Matrix>&>(Jarm_jpx_jp) : boost::none, J_vx_p ? boost::optional<vector<Matrix>&>(Jarm_jvx_jp) : boost::none, J_vx_v ? boost::optional<vector<Matrix>&>(Jarm_jvx_jv) : boost::none); } else { arm_.forwardKinematics(p.configuration(), boost::none, armjpx, vx ? boost::optional<vector<Vector3>&>(armjvx) : boost::none, J_px_p ? boost::optional<vector<Matrix>&>(Jarm_jpx_jp) : boost::none); } for (size_t i = 0; i < arm_.dof(); i++) { px[i+1] = armjpx[i]; if (J_px_p) { // see compose's jacobian (*J_px_p)[i+1].block<6,3>(0,0) = (armjpx[i].inverse() * arm_base).AdjointMap() * Harm_base; (*J_px_p)[i+1].block(0,3,6,arm_.dof()) = Jarm_jpx_jp[i]; } if (vx) { //(*vx)[i+1] = Vector3((*v)[0], (*v)[1], 0.0) + armjvx[i]; } } }
//********************************************************************** PHX_EVALUATE_FIELDS(DirichletResidual_EdgeBasis,workset) { if(workset.num_cells<=0) return; residual.deep_copy(ScalarT(0.0)); if(workset.subcell_dim==1) { Intrepid2::CellTools<ScalarT>::getPhysicalEdgeTangents(edgeTan, pointValues.jac, this->wda(workset).subcell_index, *basis->getCellTopology()); for(std::size_t c=0;c<workset.num_cells;c++) { for(int b=0;b<dof.dimension(1);b++) { for(int d=0;d<dof.dimension(2);d++) residual(c,b) += (dof(c,b,d)-value(c,b,d))*edgeTan(c,b,d); } } } else if(workset.subcell_dim==2) { // we need to compute the tangents on each edge for each cell. // how do we do this???? const shards::CellTopology & parentCell = *basis->getCellTopology(); int cellDim = parentCell.getDimension(); int numEdges = dof.dimension(1); refEdgeTan = Kokkos::createDynRankView(residual.get_kokkos_view(),"refEdgeTan",numEdges,cellDim); for(int i=0;i<numEdges;i++) { Kokkos::DynRankView<double,PHX::Device> refEdgeTan_local("refEdgeTan_local",cellDim); Intrepid2::CellTools<double>::getReferenceEdgeTangent(refEdgeTan_local, i, parentCell); for(int d=0;d<cellDim;d++) refEdgeTan(i,d) = refEdgeTan_local(d); } // Loop over workset faces and edge points for(std::size_t c=0;c<workset.num_cells;c++) { for(int pt = 0; pt < numEdges; pt++) { // Apply parent cell Jacobian to ref. edge tangent for(int i = 0; i < cellDim; i++) { edgeTan(c, pt, i) = 0.0; for(int j = 0; j < cellDim; j++){ edgeTan(c, pt, i) += pointValues.jac(c, pt, i, j)*refEdgeTan(pt,j); }// for j }// for i }// for pt }// for pCell for(std::size_t c=0;c<workset.num_cells;c++) { for(int b=0;b<dof.dimension(1);b++) { for(int d=0;d<dof.dimension(2);d++) residual(c,b) += (dof(c,b,d)-value(c,b,d))*edgeTan(c,b,d); } } } else { // don't know what to do TEUCHOS_ASSERT(false); } // loop over residuals scaling by orientation. This gurantees // everything is oriented in the "positive" direction, this allows // sums acrossed processor to be oriented in the same way (right?) for(std::size_t c=0;c<workset.num_cells;c++) { for(int b=0;b<dof.dimension(1);b++) { residual(c,b) *= dof_orientation(c,b); } } }
//-------------------------------------------------------- // add_charged_surface //-------------------------------------------------------- void ChargeRegulatorMethodEffectiveCharge::initialize( ) { ChargeRegulatorMethod::initialize(); boundary_ = atc_->is_ghost_group(atomGroupBit_); // set face sources to all point at unit function for use in integration SURFACE_SOURCE faceSources; map<PAIR, Array<XT_Function*> > & fs(faceSources[ELECTRIC_POTENTIAL]); XT_Function * f = XT_Function_Mgr::instance()->constant_function(1.); set< PAIR >::const_iterator fsItr; for (fsItr = surface_.begin(); fsItr != surface_.end(); fsItr++) { Array < XT_Function * > & dof = fs[*fsItr]; dof.reset(1); dof(0) = f; } // computed integrals of nodal shape functions on face FIELDS nodalFaceWeights; Array<bool> fieldMask(NUM_FIELDS); fieldMask(ELECTRIC_POTENTIAL) = true; (atc_->fe_engine())->compute_fluxes(fieldMask,0.,faceSources,nodalFaceWeights); const DENS_MAT & w = (nodalFaceWeights[ELECTRIC_POTENTIAL].quantity()); // Get coordinates of each node in face set for (set<int>::const_iterator n =nodes_.begin(); n != nodes_.end(); n++) { DENS_VEC x = atc_->fe_engine()->fe_mesh()->nodal_coordinates(*n); // compute effective charge at each node I // multiply charge density by integral of N_I over face double v = w(*n,0)*chargeDensity_; pair<DENS_VEC,double> p(x,v); nodeXFMap_[*n] = p; } // set up data structure holding charged faceset information FIELDS sources; double k = lammpsInterface_->coulomb_constant(); string fname = "radial_power"; double xtArgs[8]; xtArgs[0] = 0; xtArgs[1] = 0; xtArgs[2] = 0; xtArgs[3] = 1; xtArgs[4] = 1; xtArgs[5] = 1; xtArgs[6] = k*chargeDensity_; xtArgs[7] = -1.; const DENS_MAT & s(sources[ELECTRIC_POTENTIAL].quantity()); NODE_TO_XF_MAP::iterator XFitr; for (XFitr = nodeXFMap_.begin(); XFitr != nodeXFMap_.end(); XFitr++) { // evaluate voltage at each node I // set up X_T function for integration: k*chargeDensity_/||x_I - x_s|| // integral is approximated in two parts: // 1) near part with all faces within r < rcrit evaluated as 2 * pi * rcrit * k sigma A/A0, A is area of this region and A0 = pi * rcrit^2, so 2 k sigma A / rcrit // 2) far part evaluated using Gaussian quadrature on faceset DENS_VEC x((XFitr->second).first); xtArgs[0] = x(0); xtArgs[1] = x(1); xtArgs[2] = x(2); f = XT_Function_Mgr::instance()->function(fname,8,xtArgs); for (fsItr = surface_.begin(); fsItr != surface_.end(); fsItr++) { fs[*fsItr] = f; } // perform integration to get quantities at nodes on facesets // V_J' = int_S N_J k*sigma/|x_I - x_s| dS (atc_->fe_engine())->compute_fluxes(fieldMask,0.,faceSources,sources); // sum over all nodes in faceset to get total potential: // V_I = sum_J VJ' int node = XFitr->first; nodalChargePotential_[node] = s(node,0); double totalPotential = 0.; for (set<int>::const_iterator n =nodes_.begin(); n != nodes_.end(); n++) { totalPotential += s(*n,0); } // assign an XT function per each node and // then call the prescribed data manager and fix each node individually. f = XT_Function_Mgr::instance()->constant_function(totalPotential); (atc_->prescribed_data_manager())->fix_field(node,ELECTRIC_POTENTIAL,0,f); } initialized_ = true; }
double SlaveBoundaryVertices::loop_over_mesh( Mesh* mesh, MeshDomain* domain, const Settings* settings, MsqError& err ) { if (settings->get_slaved_ho_node_mode() != Settings::SLAVE_CALCULATED) { MSQ_SETERR(err)("Request to calculate higher-order node slaved status " "when Settings::get_get_slaved_ho_node_mode() " "!= SLAVE_CALCUALTED", MsqError::INVALID_STATE); return 0.0; } // If user said that we should treat fixed vertices as the // boundary, but specified that fixed vertices are defined // by the dimension of their geometric domain, then just // do distance from the geometric domain. int dim = this->domainDoF; if (dim >= 4 && settings->get_fixed_vertex_mode() != Settings::FIXED_FLAG) dim = settings->get_fixed_vertex_mode(); // Create a map to contain vertex depth. Intiliaze all to // elemDepth+1. std::vector<Mesh::VertexHandle> vertices; mesh->get_all_vertices( vertices, err ); MSQ_ERRZERO(err); if (vertices.empty()) return 0.0; std::sort( vertices.begin(), vertices.end() ); std::vector<unsigned short> depth( vertices.size(), elemDepth+1 ); BoolArr fixed( vertices.size() ); mesh->vertices_get_fixed_flag( &vertices[0], fixed.mArray, vertices.size(), err ); MSQ_ERRZERO(err); // Initialize map with boundary vertices. if (dim >= 4) { for(size_t i = 0; i < vertices.size(); ++i) if (fixed[i]) depth[i] = 0; } else { if (!domain) { MSQ_SETERR(err)("Request to calculate higher-order node slaved status " "by distance from bounding domain without a domain.", MsqError::INVALID_STATE); return 0.0; } std::vector<unsigned short> dof( vertices.size() ); domain->domain_DoF( &vertices[0], &dof[0], vertices.size(), err ); MSQ_ERRZERO(err); for (size_t i = 0; i < vertices.size(); ++i) if (dof[i] <= dim) depth[i] = 0; } // Now iterate over elements repeatedly until we've found all of the // elements near the boundary. This could be done much more efficiently // using vertex-to-element adjacencies, but it is to common for // applications not to implement that unless doing relaxation smoothing. // This is O(elemDepth * elements.size() * ln(vertices.size())); std::vector<Mesh::ElementHandle> elements; std::vector<Mesh::ElementHandle>::const_iterator j, k; std::vector<Mesh::VertexHandle> conn; std::vector<size_t> junk(2); mesh->get_all_elements( elements, err ); MSQ_ERRZERO(err); if (elements.empty()) return 0.0; bool some_changed; do { some_changed = false; for (j = elements.begin(); j != elements.end(); ++j) { conn.clear(); junk.clear(); mesh->elements_get_attached_vertices( &*j, 1, conn, junk, err ); MSQ_ERRZERO(err); unsigned short elem_depth = elemDepth+1; for (k = conn.begin(); k != conn.end(); ++k) { size_t i = std::lower_bound( vertices.begin(), vertices.end(), *k ) - vertices.begin(); if (i == vertices.size()) { MSQ_SETERR(err)("Invalid vertex handle in element connectivity list.", MsqError::INVALID_MESH); return 0.0; } if (depth[i] < elem_depth) elem_depth = depth[i]; } if (elem_depth == elemDepth+1) continue; ++elem_depth; for (k = conn.begin(); k != conn.end(); ++k) { size_t i = std::lower_bound( vertices.begin(), vertices.end(), *k ) - vertices.begin(); if (depth[i] > elem_depth) { depth[i] = elem_depth; some_changed = true; } } } // for(elements) } while (some_changed); // Now remove any corner vertices from the slaved set std::vector<Mesh::VertexHandle>::iterator p; std::vector<EntityTopology> types(elements.size()); mesh->elements_get_topologies( &elements[0], &types[0], elements.size(), err ); MSQ_ERRZERO(err); for (j = elements.begin(); j != elements.end(); ++j) { const unsigned corners = TopologyInfo::corners(types[j-elements.begin()]); conn.clear(); junk.clear(); mesh->elements_get_attached_vertices( &*j, 1, conn, junk, err ); MSQ_ERRZERO(err); for (unsigned i = 0; i < corners; ++i) { p = std::lower_bound( vertices.begin(), vertices.end(), conn[i] ); depth[p-vertices.begin()] = 0; } } // Now mark all vertices *not* within specified depth as slave vertices. std::vector<unsigned char> bytes( vertices.size() ); mesh->vertices_get_byte( &vertices[0], &bytes[0], vertices.size(), err ); MSQ_ERRZERO(err); for (size_t i = 0; i < vertices.size(); ++i) { if (depth[i] <= elemDepth || fixed[i]) bytes[i] &= ~MsqVertex::MSQ_DEPENDENT; else bytes[i] |= MsqVertex::MSQ_DEPENDENT; } mesh->vertices_set_byte( &vertices[0], &bytes[0], vertices.size(), err ); MSQ_ERRZERO(err); return 0.0; }
int TclExpCPCommand(ClientData clientData, Tcl_Interp *interp, int argc, TCL_Char **argv, Domain *theDomain) { if (theExperimentalCPs == 0) theExperimentalCPs = new ArrayOfTaggedObjects(32); // make sure there is a minimum number of arguments if (argc < 4) { opserr << "WARNING invalid number of arguments\n"; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } int tag, i, argi = 1; int nodeTag = 0, ndf = 0, ndm = 0; Node *theNode = 0; int numSignals = 0, numLim = 0, numRefType = 0; double f, lim; ExperimentalCP *theCP = 0; if (Tcl_GetInt(interp, argv[argi], &tag) != TCL_OK) { opserr << "WARNING invalid expControlPoint tag\n"; return TCL_ERROR; } argi++; if (strcmp(argv[argi],"-node") == 0) { argi++; if (Tcl_GetInt(interp, argv[argi], &nodeTag) != TCL_OK) { opserr << "WARNING invalid nodeTag for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } theNode = theDomain->getNode(nodeTag); ndf = theNode->getNumberDOF(); ndm = OPS_GetNDM(); argi++; } // count number of signals i = argi; while (i < argc) { if (strcmp(argv[i],"-fact") == 0 || strcmp(argv[i],"-factor") == 0) i += 2; else if (strcmp(argv[i],"-isRel") == 0 || strcmp(argv[i],"-isRelative") == 0) i++; else if (strcmp(argv[i],"-lim") == 0 || strcmp(argv[i],"-limit") == 0) { i += 3; numLim++; } else { i += 2; numSignals++; } } if (numSignals == 0) { opserr << "WARNING invalid number of arguments for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } if (numLim > 0 && numLim != numSignals) { opserr << "WARNING invalid number of limits for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } ID dof(numSignals); ID rspType(numSignals); Vector factor(numSignals); Vector lowerLim(numSignals); Vector upperLim(numSignals); ID isRelative(numSignals); for (i=0; i<numSignals; i++) { if (ndf == 0) { int dofID = 0; if (sscanf(argv[argi],"%d",&dofID) != 1) { if (sscanf(argv[argi],"%*[dfouDFOU]%d",&dofID) != 1) { opserr << "WARNING invalid dof for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } } dof(i) = dofID - 1; } else if (ndm == 1 && ndf == 1) { if (strcmp(argv[argi],"1") == 0 || strcmp(argv[argi],"dof1") == 0 || strcmp(argv[argi],"DOF1") == 0 || strcmp(argv[argi],"u1") == 0 || strcmp(argv[argi],"U1") == 0 || strcmp(argv[argi],"ux") == 0 || strcmp(argv[argi],"UX") == 0) dof(i) = 0; else { opserr << "WARNING invalid dof for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } } else if (ndm == 2 && ndf == 2) { if (strcmp(argv[argi],"1") == 0 || strcmp(argv[argi],"dof1") == 0 || strcmp(argv[argi],"DOF1") == 0 || strcmp(argv[argi],"u1") == 0 || strcmp(argv[argi],"U1") == 0 || strcmp(argv[argi],"ux") == 0 || strcmp(argv[argi],"UX") == 0) dof(i) = 0; else if (strcmp(argv[argi],"2") == 0 || strcmp(argv[argi],"dof2") == 0 || strcmp(argv[argi],"DOF2") == 0 || strcmp(argv[argi],"u2") == 0 || strcmp(argv[argi],"U2") == 0 || strcmp(argv[argi],"uy") == 0 || strcmp(argv[argi],"UY") == 0) dof(i) = 1; else { opserr << "WARNING invalid dof for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } } else if (ndm == 2 && ndf == 3) { if (strcmp(argv[argi],"1") == 0 || strcmp(argv[argi],"dof1") == 0 || strcmp(argv[argi],"DOF1") == 0 || strcmp(argv[argi],"u1") == 0 || strcmp(argv[argi],"U1") == 0 || strcmp(argv[argi],"ux") == 0 || strcmp(argv[argi],"UX") == 0) dof(i) = 0; else if (strcmp(argv[argi],"2") == 0 || strcmp(argv[argi],"dof2") == 0 || strcmp(argv[argi],"DOF2") == 0 || strcmp(argv[argi],"u2") == 0 || strcmp(argv[argi],"U2") == 0 || strcmp(argv[argi],"uy") == 0 || strcmp(argv[argi],"UY") == 0) dof(i) = 1; else if (strcmp(argv[argi],"3") == 0 || strcmp(argv[argi],"dof3") == 0 || strcmp(argv[argi],"DOF3") == 0 || strcmp(argv[argi],"r3") == 0 || strcmp(argv[argi],"R3") == 0 || strcmp(argv[argi],"rz") == 0 || strcmp(argv[argi],"RZ") == 0) dof(i) = 2; else { opserr << "WARNING invalid dof for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } } else if (ndm == 3 && ndf == 3) { if (strcmp(argv[argi],"1") == 0 || strcmp(argv[argi],"dof1") == 0 || strcmp(argv[argi],"DOF1") == 0 || strcmp(argv[argi],"u1") == 0 || strcmp(argv[argi],"U1") == 0 || strcmp(argv[argi],"ux") == 0 || strcmp(argv[argi],"UX") == 0) dof(i) = 0; else if (strcmp(argv[argi],"2") == 0 || strcmp(argv[argi],"dof2") == 0 || strcmp(argv[argi],"DOF2") == 0 || strcmp(argv[argi],"u2") == 0 || strcmp(argv[argi],"U2") == 0 || strcmp(argv[argi],"uy") == 0 || strcmp(argv[argi],"UY") == 0) dof(i) = 1; else if (strcmp(argv[argi],"3") == 0 || strcmp(argv[argi],"dof3") == 0 || strcmp(argv[argi],"DOF3") == 0 || strcmp(argv[argi],"u3") == 0 || strcmp(argv[argi],"U3") == 0 || strcmp(argv[argi],"uz") == 0 || strcmp(argv[argi],"UZ") == 0) dof(i) = 2; else { opserr << "WARNING invalid dof for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } } else if (ndm == 3 && ndf == 6) { if (strcmp(argv[argi],"1") == 0 || strcmp(argv[argi],"dof1") == 0 || strcmp(argv[argi],"DOF1") == 0 || strcmp(argv[argi],"u1") == 0 || strcmp(argv[argi],"U1") == 0 || strcmp(argv[argi],"ux") == 0 || strcmp(argv[argi],"UX") == 0) dof(i) = 0; else if (strcmp(argv[argi],"2") == 0 || strcmp(argv[argi],"dof2") == 0 || strcmp(argv[argi],"DOF2") == 0 || strcmp(argv[argi],"u2") == 0 || strcmp(argv[argi],"U2") == 0 || strcmp(argv[argi],"uy") == 0 || strcmp(argv[argi],"UY") == 0) dof(i) = 1; else if (strcmp(argv[argi],"3") == 0 || strcmp(argv[argi],"dof3") == 0 || strcmp(argv[argi],"DOF3") == 0 || strcmp(argv[argi],"u3") == 0 || strcmp(argv[argi],"U3") == 0 || strcmp(argv[argi],"uz") == 0 || strcmp(argv[argi],"UZ") == 0) dof(i) = 2; else if (strcmp(argv[argi],"4") == 0 || strcmp(argv[argi],"dof4") == 0 || strcmp(argv[argi],"DOF4") == 0 || strcmp(argv[argi],"r1") == 0 || strcmp(argv[argi],"R1") == 0 || strcmp(argv[argi],"rx") == 0 || strcmp(argv[argi],"RX") == 0) dof(i) = 3; else if (strcmp(argv[argi],"5") == 0 || strcmp(argv[argi],"dof5") == 0 || strcmp(argv[argi],"DOF5") == 0 || strcmp(argv[argi],"r2") == 0 || strcmp(argv[argi],"R2") == 0 || strcmp(argv[argi],"ry") == 0 || strcmp(argv[argi],"RY") == 0) dof(i) = 4; else if (strcmp(argv[argi],"6") == 0 || strcmp(argv[argi],"dof6") == 0 || strcmp(argv[argi],"DOF6") == 0 || strcmp(argv[argi],"r3") == 0 || strcmp(argv[argi],"R3") == 0 || strcmp(argv[argi],"rz") == 0 || strcmp(argv[argi],"RZ") == 0) dof(i) = 5; else { opserr << "WARNING invalid dof for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } } argi++; if (strcmp(argv[argi],"1") == 0 || strcmp(argv[argi],"dsp") == 0 || strcmp(argv[argi],"disp") == 0 || strcmp(argv[argi],"displacement") == 0) rspType(i) = OF_Resp_Disp; else if (strcmp(argv[argi],"2") == 0 || strcmp(argv[argi],"vel") == 0 || strcmp(argv[argi],"velocity") == 0) rspType(i) = OF_Resp_Vel; else if (strcmp(argv[argi],"3") == 0 || strcmp(argv[argi],"acc") == 0 || strcmp(argv[argi],"accel") == 0 || strcmp(argv[argi],"acceleration") == 0) rspType(i) = OF_Resp_Accel; else if (strcmp(argv[argi],"4") == 0 || strcmp(argv[argi],"frc") == 0 || strcmp(argv[argi],"force") == 0) rspType(i) = OF_Resp_Force; else if (strcmp(argv[argi],"5") == 0 || strcmp(argv[argi],"t") == 0 || strcmp(argv[argi],"tme") == 0 || strcmp(argv[argi],"time") == 0) rspType(i) = OF_Resp_Time; else { opserr << "WARNING invalid rspType for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } argi++; if (argi<argc && (strcmp(argv[argi],"-fact") == 0 || strcmp(argv[argi],"-factor") == 0)) { argi++; if (Tcl_GetDouble(interp, argv[argi], &f) != TCL_OK) { opserr << "WARNING invalid factor for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } factor(i) = f; argi++; } else { factor(i) = 1.0; } if (argi<argc && (strcmp(argv[argi],"-lim") == 0 || strcmp(argv[argi],"-limit") == 0)) { argi++; if (Tcl_GetDouble(interp, argv[argi], &lim) != TCL_OK) { opserr << "WARNING invalid lower limit for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } lowerLim(i) = lim; argi++; if (Tcl_GetDouble(interp, argv[argi], &lim) != TCL_OK) { opserr << "WARNING invalid upper limit for control point: " << tag << endln; printCommand(argc,argv); opserr << "Want: expControlPoint tag <-node nodeTag> dof rspType <-fact f> <-lim l u> <-isRel> ...\n"; return TCL_ERROR; } upperLim(i) = lim; argi++; } if (argi<argc && (strcmp(argv[argi],"-isRel") == 0 || strcmp(argv[argi],"-isRelative") == 0)) { isRelative(i) = 1; numRefType++; argi++; } } // parsing was successful, allocate the control point theCP = new ExperimentalCP(tag, dof, rspType, factor); if (theCP == 0) { opserr << "WARNING could not create experimental control point " << argv[1] << endln; return TCL_ERROR; } // add limits if available if (numLim > 0) theCP->setLimits(lowerLim, upperLim); // add signal reference types if available if (numRefType > 0) theCP->setSigRefType(isRelative); // add node if available if (theNode != 0) theCP->setNode(theNode); // now add the control point to the modelBuilder if (addExperimentalCP(*theCP) < 0) { delete theCP; // invoke the destructor, otherwise mem leak return TCL_ERROR; } return TCL_OK; }