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);
}
