static std::u16string symbol() {return short_name();}
string_type short_name() const {return short_name(typename Period::type());}
void ContactAction::act() { if (!_problem->getDisplacedProblem()) mooseError("Contact requires updated coordinates. Use the 'displacements = ...' line in the Mesh block."); // Determine number of dimensions unsigned int dim(1); if (_disp_y != "") ++dim; if (_disp_z != "") ++dim; std::string short_name(_name); // Chop off "Contact/" short_name.erase(0, 8); std::vector<NonlinearVariableName> vars; vars.push_back(_disp_x); vars.push_back(_disp_y); vars.push_back(_disp_z); if (_system == "Constraint") { InputParameters params = _factory.getValidParams("MechanicalContactConstraint"); // Extract global params _app.parser().extractParams(_name, params); // Create master objects params.set<std::string>("model") = _model; params.set<std::string>("formulation") = _formulation; params.set<MooseEnum>("order") = _order; params.set<BoundaryName>("boundary") = _master; params.set<BoundaryName>("slave") = _slave; params.set<Real>("penalty") = _penalty; params.set<Real>("friction_coefficient") = _friction_coefficient; params.set<Real>("tension_release") = _tension_release; params.addRequiredCoupledVar("nodal_area", "The nodal area"); params.set<std::vector<VariableName> >("nodal_area") = std::vector<VariableName>(1, "nodal_area_"+short_name); if (isParamValid("tangential_tolerance")) params.set<Real>("tangential_tolerance") = getParam<Real>("tangential_tolerance"); if (isParamValid("normal_smoothing_distance")) params.set<Real>("normal_smoothing_distance") = getParam<Real>("normal_smoothing_distance"); if (isParamValid("normal_smoothing_method")) params.set<std::string>("normal_smoothing_method") = getParam<std::string>("normal_smoothing_method"); params.addCoupledVar("disp_x", "The x displacement"); params.set<std::vector<VariableName> >("disp_x") = std::vector<VariableName>(1, _disp_x); params.addCoupledVar("disp_y", "The y displacement"); if (dim > 1) params.set<std::vector<VariableName> >("disp_y") = std::vector<VariableName>(1, _disp_y); params.addCoupledVar("disp_z", "The z displacement"); if (dim == 3) params.set<std::vector<VariableName> >("disp_z") = std::vector<VariableName>(1, _disp_z); params.set<bool>("use_displaced_mesh") = true; for (unsigned int i(0); i < dim; ++i) { std::stringstream name; name << short_name; name << "_constraint_"; name << i; params.set<unsigned int>("component") = i; params.set<NonlinearVariableName>("variable") = vars[i]; params.set<std::vector<VariableName> >("master_variable") = std::vector<VariableName>(1,vars[i]); _problem->addConstraint("MechanicalContactConstraint", name.str(), params); } } else if (_system == "DiracKernel") { { InputParameters params = _factory.getValidParams("ContactMaster"); // Extract global params _app.parser().extractParams(_name, params); // Create master objects params.set<std::string>("model") = _model; params.set<std::string>("formulation") = _formulation; params.set<MooseEnum>("order") = _order; params.set<BoundaryName>("boundary") = _master; params.set<BoundaryName>("slave") = _slave; params.set<Real>("penalty") = _penalty; params.set<Real>("friction_coefficient") = _friction_coefficient; params.set<Real>("tension_release") = _tension_release; params.addRequiredCoupledVar("nodal_area", "The nodal area"); params.set<std::vector<VariableName> >("nodal_area") = std::vector<VariableName>(1, "nodal_area_"+short_name); if (isParamValid("tangential_tolerance")) params.set<Real>("tangential_tolerance") = getParam<Real>("tangential_tolerance"); if (isParamValid("normal_smoothing_distance")) params.set<Real>("normal_smoothing_distance") = getParam<Real>("normal_smoothing_distance"); if (isParamValid("normal_smoothing_method")) params.set<std::string>("normal_smoothing_method") = getParam<std::string>("normal_smoothing_method"); params.addCoupledVar("disp_x", "The x displacement"); params.set<std::vector<VariableName> >("disp_x") = std::vector<VariableName>(1, _disp_x); params.addCoupledVar("disp_y", "The y displacement"); if (dim > 1) params.set<std::vector<VariableName> >("disp_y") = std::vector<VariableName>(1, _disp_y); params.addCoupledVar("disp_z", "The z displacement"); if (dim == 3) params.set<std::vector<VariableName> >("disp_z") = std::vector<VariableName>(1, _disp_z); params.set<bool>("use_displaced_mesh") = true; for (unsigned int i(0); i < dim; ++i) { std::stringstream name; name << short_name; name << "_master_"; name << i; params.set<unsigned int>("component") = i; params.set<NonlinearVariableName>("variable") = vars[i]; _problem->addDiracKernel("ContactMaster", name.str(), params); } } { InputParameters params = _factory.getValidParams("SlaveConstraint"); // Extract global params _app.parser().extractParams(_name, params); // Create slave objects params.set<std::string>("model") = _model; params.set<std::string>("formulation") = _formulation; params.set<MooseEnum>("order") = _order; params.set<BoundaryName>("boundary") = _slave; params.set<BoundaryName>("master") = _master; params.set<Real>("penalty") = _penalty; params.set<Real>("friction_coefficient") = _friction_coefficient; params.addRequiredCoupledVar("nodal_area", "The nodal area"); params.set<std::vector<VariableName> >("nodal_area") = std::vector<VariableName>(1, "nodal_area_"+short_name); if (isParamValid("tangential_tolerance")) params.set<Real>("tangential_tolerance") = getParam<Real>("tangential_tolerance"); if (isParamValid("normal_smoothing_distance")) params.set<Real>("normal_smoothing_distance") = getParam<Real>("normal_smoothing_distance"); if (isParamValid("normal_smoothing_method")) params.set<std::string>("normal_smoothing_method") = getParam<std::string>("normal_smoothing_method"); params.addCoupledVar("disp_x", "The x displacement"); params.set<std::vector<VariableName> >("disp_x") = std::vector<VariableName>(1, _disp_x); params.addCoupledVar("disp_y", "The y displacement"); if (dim > 1) params.set<std::vector<VariableName> >("disp_y") = std::vector<VariableName>(1, _disp_y); params.addCoupledVar("disp_z", "The z displacement"); if (dim == 3) params.set<std::vector<VariableName> >("disp_z") = std::vector<VariableName>(1, _disp_z); params.set<bool>("use_displaced_mesh") = true; for (unsigned int i(0); i < dim; ++i) { std::stringstream name; name << short_name; name << "_slave_"; name << i; params.set<unsigned int>("component") = i; params.set<NonlinearVariableName>("variable") = vars[i]; _problem->addDiracKernel("SlaveConstraint", name.str(), params); } } } else mooseError("Invalid system for contact constraint enforcement: "<<_system); ++counter; }
static std::basic_string<CharT> symbol() {return short_name();}
std::string Entity::long_name() const { std::stringstream ss; ss << short_name() << '_' << std::setw(4) << std::setfill('0') << ident; return ss.str(); }
void SolidMechanicsAction::act() { // list of subdomains IDs per coordinate system std::map<Moose::CoordinateSystemType, std::vector<SubdomainName> > coord_map; std::set<SubdomainID> subdomains; if (isParamValid("block")) // Should it be restricted to certain blocks? { Moose::out<<"Restricting to blocks!"<<std::endl; std::vector<SubdomainName> block = getParam<std::vector<SubdomainName> >("block"); for (unsigned int i=0; i < block.size(); i++) subdomains.insert(_problem->mesh().getSubdomainID(block[i])); } else // Put it everywhere subdomains = _problem->mesh().meshSubdomains(); for (std::set<SubdomainID>::const_iterator it = subdomains.begin(); it != subdomains.end(); ++it) { SubdomainID sid = *it; Moose::CoordinateSystemType coord_type = _problem->getCoordSystem(sid); // Convert the SubdomainID into SubdomainName since kernel params take SubdomainNames (this is retarded...) std::stringstream ss; ss << sid; SubdomainName sname = ss.str(); coord_map[coord_type].push_back(sname); } for (std::map<Moose::CoordinateSystemType, std::vector<SubdomainName> >::iterator it = coord_map.begin(); it != coord_map.end(); ++it) { Moose::CoordinateSystemType coord_type = (*it).first; std::vector<SubdomainName> & blocks = (*it).second; // Determine whether RZ or RSPHERICAL bool rz(false); bool rspherical(false); unsigned int dim(1); std::vector<std::string> keys; std::vector<VariableName> vars; std::vector<std::vector<AuxVariableName> > save_in; std::vector<std::vector<AuxVariableName> > diag_save_in; std::string type("StressDivergence"); if (getParam<MooseEnum>("type") == 0) // truss { type = "StressDivergenceTruss"; } else if (coord_type == Moose::COORD_RZ) { rz = true; type = "StressDivergenceRZ"; dim = 2; keys.push_back("disp_r"); keys.push_back("disp_z"); vars.push_back(_disp_r); vars.push_back(_disp_z); save_in.resize(dim); if (isParamValid("save_in_disp_r")) save_in[0] = getParam<std::vector<AuxVariableName> >("save_in_disp_r"); if (isParamValid("save_in_disp_z")) save_in[1] = getParam<std::vector<AuxVariableName> >("save_in_disp_z"); diag_save_in.resize(dim); if (isParamValid("diag_save_in_disp_r")) diag_save_in[0] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_r"); if (isParamValid("diag_save_in_disp_z")) diag_save_in[1] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_z"); } else if (coord_type == Moose::COORD_RSPHERICAL) { rspherical = true; type = "StressDivergenceRSpherical"; dim = 1; keys.push_back("disp_r"); vars.push_back(_disp_r); save_in.resize(dim); if (isParamValid("save_in_disp_r")) save_in[0] = getParam<std::vector<AuxVariableName> >("save_in_disp_r"); diag_save_in.resize(dim); if (isParamValid("diag_save_in_disp_r")) diag_save_in[0] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_r"); } if (!rz && !rspherical && _disp_x == "") { mooseError("disp_x must be specified"); } if (!rz && !rspherical) { keys.push_back("disp_x"); vars.push_back(_disp_x); if ( _disp_y != "" ) { ++dim; keys.push_back("disp_y"); vars.push_back(_disp_y); if ( _disp_z != "" ) { ++dim; keys.push_back("disp_z"); vars.push_back(_disp_z); } } save_in.resize(dim); if (isParamValid("save_in_disp_x")) save_in[0] = getParam<std::vector<AuxVariableName> >("save_in_disp_x"); if (isParamValid("save_in_disp_y")) save_in[1] = getParam<std::vector<AuxVariableName> >("save_in_disp_y"); if (isParamValid("save_in_disp_z")) save_in[2] = getParam<std::vector<AuxVariableName> >("save_in_disp_z"); diag_save_in.resize(dim); if (isParamValid("diag_save_in_disp_x")) diag_save_in[0] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_x"); if (isParamValid("diag_save_in_disp_y")) diag_save_in[1] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_y"); if (isParamValid("diag_save_in_disp_z")) diag_save_in[2] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_z"); } unsigned int num_coupled(dim); if (_temp != "") { ++num_coupled; keys.push_back("temp"); vars.push_back(_temp); } // Create divergence objects std::string short_name(_name); // Chop off "SolidMechanics/" short_name.erase(0, 15); InputParameters params = _factory.getValidParams(type); for (unsigned j(0); j < num_coupled; ++j) { params.addCoupledVar(keys[j], ""); params.set<std::vector<VariableName> >(keys[j]) = std::vector<VariableName>(1, vars[j]); } params.set<bool>("use_displaced_mesh") = getParam<bool>("use_displaced_mesh"); params.set<std::string>("appended_property_name") = getParam<std::string>("appended_property_name"); for (unsigned int i(0); i < dim; ++i) { std::stringstream name; name << "Kernels/"; name << short_name; name << i; params.set<unsigned int>("component") = i; params.set<NonlinearVariableName>("variable") = vars[i]; params.set<std::vector<SubdomainName> >("block") = blocks; params.set<std::vector<AuxVariableName> >("save_in") = save_in[i]; params.set<std::vector<AuxVariableName> >("diag_save_in") = diag_save_in[i]; _problem->addKernel(type, name.str(), params); } } }
// much easier and catches virtual ports too !! void PortEnumW32::EnumSerial(unsigned long& port_items) { HKEY hkCommMap; if (ERROR_SUCCESS != ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("HARDWARE\\DEVICEMAP\\SERIALCOMM"), 0, KEY_QUERY_VALUE, &hkCommMap)) { wxASSERT(false); return; } void* pValNameBuff = 0; void* pValueBuff = 0; DWORD dwValCount, dwMaxCharValNameLen, dwMaxByteValueSize; if (ERROR_SUCCESS != ::RegQueryInfoKey(hkCommMap, NULL, NULL, NULL, NULL, NULL, NULL, &dwValCount, &dwMaxCharValNameLen, &dwMaxByteValueSize, NULL, NULL)) {// regkey enum failed !! ::RegCloseKey(hkCommMap); wxASSERT(false); return; // ERROR EXIT } // The max value name size is returned in TCHARs not including the terminating null character. dwMaxCharValNameLen++; pValNameBuff = new TCHAR[dwMaxCharValNameLen]; if (!pValNameBuff) {// no memory !! ::RegCloseKey(hkCommMap); wxASSERT(false); return; // ERROR EXIT } // The max needed data size is returned in bytes dwMaxByteValueSize+=sizeof(TCHAR); DWORD dwMaxCharValueLen = (dwMaxByteValueSize/2) * sizeof(TCHAR); // num of TCHARS pValueBuff = new TCHAR[dwMaxCharValueLen]; if (!pValueBuff) { // no memory !! ::RegCloseKey(hkCommMap); delete pValNameBuff; wxASSERT(false); return; // ERROR EXIT } for (DWORD dwIndex = 0; dwIndex < dwValCount; ++dwIndex) { DWORD dwCharValNameSize = dwMaxCharValNameLen; DWORD dwByteValueSize = dwMaxCharValueLen*sizeof(TCHAR);; DWORD dwType; LONG nRes = ::RegEnumValue(hkCommMap, dwIndex, (LPTSTR)pValNameBuff,&dwCharValNameSize, NULL, &dwType, (LPBYTE)pValueBuff, &dwByteValueSize); if (nRes != ERROR_SUCCESS) { break; // no more } if (dwType != REG_SZ) { continue; // not expected type - try next } // now we have name and value in the buffers (TCHAR) wxString short_name((LPCTSTR)pValueBuff); m_pPorts[port_items] = new wxPortDescr(); m_pPorts[port_items]->Init(port_items, short_name, 0, short_name, true, true, // +guide +LX true, false, false, false, false); port_items++; }//for // clean up ::RegCloseKey(hkCommMap); delete pValNameBuff; delete pValueBuff; }
Private::Data Private::GenerateTree(aop::CallGraph && cg) { Private::Data data { Private::Node(), std::move(cg.table), nullptr, nullptr }; QVector<QString> short_name(cg.root.value + 1U); QVector<QString> signature (cg.root.value + 1U); { /* get a map from id to signature */ short_name[0] = "error!"; for (auto & pair : data.table) { /* extract signature */ signature[pair.second] = std::move(QString::fromStdString(pair.first)); /* extract abbreviation. SEPCIAL THX to @frantic1048 */ QRegularExpression regex("(~?\\w+|operator(?:\\s*).+)(?=\\(.*\\))"); QRegularExpressionMatch match = regex.match(signature[pair.second]); if (match.hasMatch()) short_name[pair.second] = std::move(match.captured(1)); else short_name[pair.second] = signature[pair.second]; } } auto root = Private::Node { cg.root.value, new QStandardItem, Private::Node::child_t() }; { /* build the tree via BFS */ QQueue<aop::Node const *> src_queue; QQueue<Private::Node *> dst_queue; src_queue.enqueue(&cg.root); dst_queue.enqueue(&root); while(!src_queue.empty()) { auto src = src_queue.dequeue(); auto dst = dst_queue.dequeue(); /* [important]to aovid dst->children resize when push_back * Private::Node pointer will be invalid after resize */ dst->children.reserve(src->children.size()); for (auto & child : src->children) { auto fst_item = new QStandardItem(short_name[child.value]); auto snd_item = new QStandardItem(signature [child.value]); fst_item->setEditable(false); snd_item->setEditable(false); dst->item->appendRow({fst_item, snd_item}); dst->children.push_back(Private::Node{ child.value, fst_item, Private::Node::child_t() }); if (!child.children.empty()) { src_queue.enqueue(&child); dst_queue.enqueue(&dst->children.back()); } } } } data.tree = new QStandardItemModel(root.item->rowCount(), root.item->columnCount()); { /* Set model properties */ data.tree->setHorizontalHeaderItem(0, new QStandardItem(FileViewHeader1)); data.tree->setHorizontalHeaderItem(1, new QStandardItem(FileViewHeader2)); for (auto r = 0, rc = root.item->rowCount(); r < rc; r++) for (auto c = 0, cc = root.item->columnCount(); c < cc; c++) data.tree->setItem(r, c, root.item->takeChild(r, c)); } delete root.item; root.item = nullptr; std::swap(data.root, root); return std::move(data); }