bool NodePartitionedMeshReader::readCastNodesASCII(std::ifstream& is_node,
const int part_id, std::vector<MeshLib::Node*> &mesh_nodes,
std::vector<unsigned long> &glb_node_ids) const
{
int const message_tag = 0;
// MPI_Send/Recv can handle only int. Check for overflow.
if (!is_safely_convertable<unsigned long, int>(_mesh_info.nodes))
{
ERR("Too large number of nodes to read.");
return false;
}
std::vector<NodeData> nodes(_mesh_info.nodes);
if(_mpi_rank == 0)
{
for(unsigned long k = 0; k < _mesh_info.nodes; k++)
{
NodeData &node = nodes[k];
is_node >> node.index >> node.x >> node.y >> node.z >> std::ws;
}
if(part_id == 0)
setNodes(nodes, mesh_nodes, glb_node_ids);
else
MPI_Send(nodes.data(), static_cast<int>(_mesh_info.nodes),
_mpi_node_type, part_id, message_tag, _mpi_comm);
}
else if(_mpi_rank == part_id)
// set player name
void LiveInfo::setPlayer( int color, const QString &txt )
{
(color == cheng4::ctWhite ? ui->engineLabel : ui->engineLabel_2)->setText( txt );
// reset engine stats
setDepth( color, 0 );
setScore( color, 0 );
setNodes( color, 0, 0 );
setPV( color, QString() );
}
MeshLib::NodePartitionedMesh* NodePartitionedMeshReader::readBinary(
const std::string &file_name_base)
{
//----------------------------------------------------------------------------------
// Read headers
const std::string fname_header = file_name_base + "_partitioned_msh_";
const std::string fname_num_p_ext = std::to_string(_mpi_comm_size) + ".bin";
if (!readBinaryDataFromFile(fname_header + "cfg" + fname_num_p_ext,
static_cast<MPI_Offset>(
static_cast<unsigned>(_mpi_rank) * sizeof(_mesh_info)),
MPI_LONG, _mesh_info))
return nullptr;
//----------------------------------------------------------------------------------
// Read Nodes
std::vector<NodeData> nodes(_mesh_info.nodes);
if (!readBinaryDataFromFile(fname_header + "nod" + fname_num_p_ext,
static_cast<MPI_Offset>(_mesh_info.offset[2]), _mpi_node_type, nodes))
return nullptr;
std::vector<MeshLib::Node*> mesh_nodes;
std::vector<unsigned long> glb_node_ids;
setNodes(nodes, mesh_nodes, glb_node_ids);
//----------------------------------------------------------------------------------
// Read non-ghost elements
std::vector<unsigned long> elem_data(
_mesh_info.regular_elements + _mesh_info.offset[0]);
if (!readBinaryDataFromFile(fname_header + "ele" + fname_num_p_ext,
static_cast<MPI_Offset>(_mesh_info.offset[3]), MPI_LONG, elem_data))
return nullptr;
std::vector<MeshLib::Element*> mesh_elems(
_mesh_info.regular_elements + _mesh_info.ghost_elements);
setElements(mesh_nodes, elem_data, mesh_elems);
//----------------------------------------------------------------------------------
//Read ghost element
std::vector<unsigned long> ghost_elem_data(
_mesh_info.ghost_elements + _mesh_info.offset[1]);
if (!readBinaryDataFromFile(fname_header + "ele_g" + fname_num_p_ext,
static_cast<MPI_Offset>(_mesh_info.offset[4]), MPI_LONG, ghost_elem_data))
return nullptr;
const bool process_ghost = true;
setElements(mesh_nodes, ghost_elem_data, mesh_elems, process_ghost);
//----------------------------------------------------------------------------------
return newMesh(BaseLib::extractBaseName(file_name_base),
mesh_nodes, glb_node_ids, mesh_elems);
}
Datum
spg_quad_inner_consistent(PG_FUNCTION_ARGS)
{
spgInnerConsistentIn *in = (spgInnerConsistentIn *) PG_GETARG_POINTER(0);
spgInnerConsistentOut *out = (spgInnerConsistentOut *) PG_GETARG_POINTER(1);
Point *query,
*centroid;
BOX *boxQuery;
query = DatumGetPointP(in->query);
Assert(in->hasPrefix);
centroid = DatumGetPointP(in->prefixDatum);
if (in->allTheSame)
{
/* Report that all nodes should be visited */
int i;
out->nNodes = in->nNodes;
out->nodeNumbers = (int *) palloc(sizeof(int) * in->nNodes);
for (i = 0; i < in->nNodes; i++)
out->nodeNumbers[i] = i;
PG_RETURN_VOID();
}
Assert(in->nNodes == 4);
out->nodeNumbers = (int *) palloc(sizeof(int) * 4);
switch (in->strategy)
{
case RTLeftStrategyNumber:
setNodes(out, SPTEST(point_left, centroid, query), 3, 4);
break;
case RTRightStrategyNumber:
setNodes(out, SPTEST(point_right, centroid, query), 1, 2);
break;
case RTSameStrategyNumber:
out->nNodes = 1;
out->nodeNumbers[0] = getQuadrant(centroid, query) - 1;
break;
case RTBelowStrategyNumber:
setNodes(out, SPTEST(point_below, centroid, query), 2, 3);
break;
case RTAboveStrategyNumber:
setNodes(out, SPTEST(point_above, centroid, query), 1, 4);
break;
case RTContainedByStrategyNumber:
/*
* For this operator, the query is a box not a point. We cheat to
* the extent of assuming that DatumGetPointP won't do anything
* that would be bad for a pointer-to-box.
*/
boxQuery = DatumGetBoxP(in->query);
if (DatumGetBool(DirectFunctionCall2(box_contain_pt,
PointerGetDatum(boxQuery),
PointerGetDatum(centroid))))
{
/* centroid is in box, so descend to all quadrants */
setNodes(out, true, 0, 0);
}
else
{
/* identify quadrant(s) containing all corners of box */
Point p;
int i,
r = 0;
p = boxQuery->low;
r |= 1 << (getQuadrant(centroid, &p) - 1);
p.y = boxQuery->high.y;
r |= 1 << (getQuadrant(centroid, &p) - 1);
p = boxQuery->high;
r |= 1 << (getQuadrant(centroid, &p) - 1);
p.x = boxQuery->low.x;
r |= 1 << (getQuadrant(centroid, &p) - 1);
/* we must descend into those quadrant(s) */
out->nNodes = 0;
for (i = 0; i < 4; i++)
{
if (r & (1 << i))
{
out->nodeNumbers[out->nNodes] = i;
out->nNodes++;
}
}
}
break;
default:
elog(ERROR, "unrecognized strategy number: %d", in->strategy);
break;
}
PG_RETURN_VOID();
}
Foam::octree<Type>::octree
(
const treeBoundBox& octreeBb,
const Type& shapes,
const label minNLevels,
const scalar maxLeafRatio,
const scalar maxShapeRatio
)
:
topNode_(new treeNode<Type>(octreeBb)),
shapes_(shapes),
octreeBb_(octreeBb),
maxLeafRatio_(maxLeafRatio),
maxShapeRatio_(maxShapeRatio),
minNLevels_(minNLevels),
deepestLevel_(0),
nEntries_(0),
nNodes_(0),
nLeaves_(0),
endIter_(*this, -1),
endConstIter_(*this, -1)
{
cpuTime timer;
setNodes(nNodes() + 1);
const label nShapes = shapes_.size();
labelList indices(nShapes);
for (label i = 0; i < nShapes; i++)
{
indices[i] = i;
}
// Create initial level (0) of subLeaves
if (debug & 1)
{
Pout<< "octree : --- Start of Level " << deepestLevel_
<< " ----" << endl;
}
topNode_->distribute(0, *this, shapes_, indices);
if (debug & 1)
{
printStats(Pout);
Pout<< "octree : --- End of Level " << deepestLevel_
<< " ----" << endl;
}
// Breadth first creation of tree
// Stop if: - level above minlevel and
// - less than so many cells per endpoint
// (so bottom level is fine enough)
// - every shape mentioned in only so many
// leaves. (if shape bb quite big it will end up
// in lots of leaves).
// - no change in number of leaves
// (happens if leafs fine enough)
// This guarantees that tree
// - is fine enough (if minLevel > 0)
// - has some guaranteed maximum size (maxShapeRatio)
label oldNLeaves = -1; // make test below pass first time.
deepestLevel_ = 1;
while
(
(deepestLevel_ <= minNLevels_)
|| (
(nEntries() > maxLeafRatio * nLeaves()) // shapes per leaf
&& (nEntries() < maxShapeRatio * nShapes) // entries per shape
)
)
{
if (deepestLevel_ >= maxNLevels)
{
if (debug & 1)
{
Pout<< "octree : exiting since maxNLevels "
<< maxNLevels << " reached" << endl;
}
break;
}
if (oldNLeaves == nLeaves())
{
if (debug & 1)
{
Pout<< "octree : exiting since nLeaves does not change"
<< endl;
}
break;
}
if (debug & 1)
{
Pout<< "octree : --- Start of Level " << deepestLevel_
<< " ----" << endl;
}
oldNLeaves = nLeaves();
topNode_->redistribute
(
1,
*this,
shapes_,
deepestLevel_
);
if (debug & 1)
{
printStats(Pout);
Pout<< "octree : --- End of Level " << deepestLevel_
<< " ----" << endl;
}
deepestLevel_++;
}
if (debug & 1)
{
Pout<< "octree : Constructed octree in = "
<< timer.cpuTimeIncrement()
<< " s\n" << endl << endl;
}
// Set volume type of non-treeleaf nodes.
topNode_->setSubNodeType(0, *this, shapes_);
if (debug & 1)
{
Pout<< "octree : Added node information to octree in = "
<< timer.cpuTimeIncrement()
<< " s\n" << endl << endl;
}
}
void
NIXMLEdgesHandler::addEdge(const SUMOSAXAttributes& attrs) {
myIsUpdate = false;
bool ok = true;
// initialise the edge
myCurrentEdge = 0;
mySplits.clear();
// get the id, report an error if not given or empty...
myCurrentID = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
myCurrentEdge = myEdgeCont.retrieve(myCurrentID);
// check deprecated (unused) attributes
// use default values, first
myCurrentSpeed = myTypeCont.getSpeed("");
myCurrentPriority = myTypeCont.getPriority("");
myCurrentLaneNo = myTypeCont.getNumLanes("");
myPermissions = myTypeCont.getPermissions("");
myCurrentWidth = myTypeCont.getWidth("");
myCurrentOffset = NBEdge::UNSPECIFIED_OFFSET;
myCurrentType = "";
myShape = PositionVector();
myLanesSpread = LANESPREAD_RIGHT;
myLength = NBEdge::UNSPECIFIED_LOADED_LENGTH;
myCurrentStreetName = "";
myReinitKeepEdgeShape = false;
// check whether a type's values shall be used
if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
myCurrentType = attrs.get<std::string>(SUMO_ATTR_TYPE, myCurrentID.c_str(), ok);
if (!ok) {
return;
}
if (!myTypeCont.knows(myCurrentType)) {
WRITE_ERROR("Type '" + myCurrentType + "' used by edge '" + myCurrentID + "' was not defined.");
return;
}
myCurrentSpeed = myTypeCont.getSpeed(myCurrentType);
myCurrentPriority = myTypeCont.getPriority(myCurrentType);
myCurrentLaneNo = myTypeCont.getNumLanes(myCurrentType);
myPermissions = myTypeCont.getPermissions(myCurrentType);
myCurrentWidth = myTypeCont.getWidth(myCurrentType);
}
// use values from the edge to overwrite if existing, then
if (myCurrentEdge != 0) {
myIsUpdate = true;
if (!myHaveReportedAboutOverwriting) {
WRITE_MESSAGE("Duplicate edge id occured ('" + myCurrentID + "'); assuming overwriting is wished.");
myHaveReportedAboutOverwriting = true;
}
if (attrs.getOpt<bool>(SUMO_ATTR_REMOVE, myCurrentID.c_str(), ok, false)) {
myEdgeCont.erase(myDistrictCont, myCurrentEdge);
myCurrentEdge = 0;
return;
}
myCurrentSpeed = myCurrentEdge->getSpeed();
myCurrentPriority = myCurrentEdge->getPriority();
myCurrentLaneNo = myCurrentEdge->getNumLanes();
myCurrentType = myCurrentEdge->getTypeID();
myPermissions = myCurrentEdge->getPermissions();
if (!myCurrentEdge->hasDefaultGeometry()) {
myShape = myCurrentEdge->getGeometry();
myReinitKeepEdgeShape = true;
}
myCurrentWidth = myCurrentEdge->getLaneWidth();
myCurrentOffset = myCurrentEdge->getOffset();
myLanesSpread = myCurrentEdge->getLaneSpreadFunction();
if (myCurrentEdge->hasLoadedLength()) {
myLength = myCurrentEdge->getLoadedLength();
}
myCurrentStreetName = myCurrentEdge->getStreetName();
}
// speed, priority and the number of lanes have now default values;
// try to read the real values from the file
if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
myCurrentSpeed = attrs.get<SUMOReal>(SUMO_ATTR_SPEED, myCurrentID.c_str(), ok);
}
if (myOptions.getBool("speed-in-kmh")) {
myCurrentSpeed = myCurrentSpeed / (SUMOReal) 3.6;
}
// try to get the number of lanes
if (attrs.hasAttribute(SUMO_ATTR_NUMLANES)) {
myCurrentLaneNo = attrs.get<int>(SUMO_ATTR_NUMLANES, myCurrentID.c_str(), ok);
}
// try to get the priority
if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) {
myCurrentPriority = attrs.get<int>(SUMO_ATTR_PRIORITY, myCurrentID.c_str(), ok);
}
// try to get the width
if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
myCurrentWidth = attrs.get<SUMOReal>(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok);
}
// try to get the width
if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
myCurrentOffset = attrs.get<SUMOReal>(SUMO_ATTR_ENDOFFSET, myCurrentID.c_str(), ok);
}
// try to get the street name
myCurrentStreetName = attrs.getOpt<std::string>(SUMO_ATTR_NAME, myCurrentID.c_str(), ok, myCurrentStreetName);
// try to get the allowed/disallowed classes
if (attrs.hasAttribute(SUMO_ATTR_ALLOW) || attrs.hasAttribute(SUMO_ATTR_DISALLOW)) {
std::string allowS = attrs.hasAttribute(SUMO_ATTR_ALLOW) ? attrs.getStringSecure(SUMO_ATTR_ALLOW, "") : "";
std::string disallowS = attrs.hasAttribute(SUMO_ATTR_DISALLOW) ? attrs.getStringSecure(SUMO_ATTR_DISALLOW, "") : "";
// XXX matter of interpretation: should updated permissions replace or extend previously set permissions?
myPermissions = parseVehicleClasses(allowS, disallowS);
}
// try to set the nodes
if (!setNodes(attrs)) {
// return if this failed
return;
}
// try to get the shape
myShape = tryGetShape(attrs);
// try to get the spread type
myLanesSpread = tryGetLaneSpread(attrs);
// try to get the length
myLength = attrs.getOpt<SUMOReal>(SUMO_ATTR_LENGTH, myCurrentID.c_str(), ok, myLength);
// insert the parsed edge into the edges map
if (!ok) {
return;
}
// check whether a previously defined edge shall be overwritten
if (myCurrentEdge != 0) {
myCurrentEdge->reinit(myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myShape,
myCurrentWidth, myCurrentOffset,
myCurrentStreetName, myLanesSpread,
myReinitKeepEdgeShape);
} else {
// the edge must be allocated in dependence to whether a shape is given
if (myShape.size() == 0) {
myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myCurrentWidth, myCurrentOffset,
myCurrentStreetName, myLanesSpread);
} else {
myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myCurrentWidth, myCurrentOffset,
myShape, myCurrentStreetName, myLanesSpread,
myKeepEdgeShape);
}
}
myCurrentEdge->setLoadedLength(myLength);
myCurrentEdge->setPermissions(myPermissions);
}
