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