Pairing * TripletThetaPhiPredictor::run(HitCollection & hits, const DetectorGeometry & geom, const GeometrySupplement & geomSupplement, const Dictionary & dict,
int nThreads, const TripletConfigurations & layerTriplets, const Grid & grid, const Pairing & pairs){
uint nPairs = pairs.pairing.get_count();
LOG << "Initializing prefix sum for prediction...";
clever::vector<uint, 1> m_prefixSum(0, nPairs+1, ctx);
LOG << "done[" << m_prefixSum.get_count() << "]" << std::endl;
uint nGroups = (uint) std::max(1.0f, ceil(((float) nPairs)/nThreads));
LOG << "Running predict kernel...";
cl_event evt = predictCount.run(
//detector geometry
geom.transfer.buffer(RadiusDict()), dict.transfer.buffer(Radius()), geomSupplement.transfer.buffer(MinRadius()), geomSupplement.transfer.buffer(MaxRadius()),
grid.transfer.buffer(Boundary()), layerTriplets.transfer.buffer(Layer3()), grid.config.nLayers,
grid.config.MIN_Z, grid.config.sectorSizeZ(), grid.config.nSectorsZ,
grid.config.MIN_PHI, grid.config.sectorSizePhi(), grid.config.nSectorsPhi,
//configuration
layerTriplets.transfer.buffer(sigmaZ()), layerTriplets.transfer.buffer(sigmaPhi()), layerTriplets.minRadiusCurvature(),
// input
pairs.pairing.get_mem(), nPairs,
hits.transfer.buffer(GlobalX()), hits.transfer.buffer(GlobalY()), hits.transfer.buffer(GlobalZ()),
hits.transfer.buffer(EventNumber()), hits.transfer.buffer(DetectorLayer()),
hits.transfer.buffer(DetectorId()), hits.transfer.buffer(HitId()),
// output
m_prefixSum.get_mem(),
//thread config
range(nGroups * nThreads),
range(nThreads));
TripletThetaPhiPredictor::events.push_back(evt);
LOG << "done" << std::endl;
if(PROLIX){
PLOG << "Fetching prefix sum for prediction...";
std::vector<uint> vPrefixSum(m_prefixSum.get_count());
transfer::download(m_prefixSum,vPrefixSum,ctx);
PLOG << "done" << std::endl;
PLOG << "Prefix sum: ";
for(auto i : vPrefixSum){
PLOG << i << " ; ";
}
PLOG << std::endl;
}
//Calculate prefix sum
PrefixSum prefixSum(ctx);
evt = prefixSum.run(m_prefixSum.get_mem(), m_prefixSum.get_count(), nThreads, TripletThetaPhiPredictor::events);
uint nFoundTripletCandidates;
transfer::downloadScalar(m_prefixSum, nFoundTripletCandidates, ctx, true, m_prefixSum.get_count()-1, 1, &evt);
if(PROLIX){
PLOG << "Fetching prefix sum for prediction...";
std::vector<uint> vPrefixSum(m_prefixSum.get_count());
transfer::download(m_prefixSum,vPrefixSum,ctx);
PLOG << "done" << std::endl;
PLOG << "Prefix sum: ";
for(auto i : vPrefixSum){
PLOG << i << " ; ";
}
PLOG << std::endl;
}
LOG << "Initializing triplet candidates...";
Pairing * m_triplets = new Pairing(ctx, nFoundTripletCandidates, grid.config.nEvents, layerTriplets.size());
LOG << "done[" << m_triplets->pairing.get_count() << "]" << std::endl;
LOG << "Running predict store kernel...";
evt = predictStore.run(
//geometry
geom.transfer.buffer(RadiusDict()), dict.transfer.buffer(Radius()), geomSupplement.transfer.buffer(MinRadius()), geomSupplement.transfer.buffer(MaxRadius()),
grid.transfer.buffer(Boundary()), layerTriplets.transfer.buffer(Layer3()), grid.config.nLayers,
grid.config.MIN_Z, grid.config.sectorSizeZ(), grid.config.nSectorsZ,
grid.config.MIN_PHI, grid.config.sectorSizePhi(), grid.config.nSectorsPhi,
//configuration
layerTriplets.transfer.buffer(sigmaZ()), layerTriplets.transfer.buffer(sigmaPhi()), layerTriplets.size(), layerTriplets.minRadiusCurvature(),
//input
pairs.pairing.get_mem(), pairs.pairing.get_count(),
hits.transfer.buffer(GlobalX()), hits.transfer.buffer(GlobalY()), hits.transfer.buffer(GlobalZ()),
hits.transfer.buffer(EventNumber()), hits.transfer.buffer(DetectorLayer()),
hits.transfer.buffer(DetectorId()),
//oracle
m_prefixSum.get_mem(),
// output
m_triplets->pairing.get_mem(), m_triplets->pairingOffsets.get_mem(),
//thread config
range(nGroups * nThreads),
range(nThreads));
TripletThetaPhiPredictor::events.push_back(evt);
LOG << "done" << std::endl;
LOG << "Running filter offset monotonize kernel...";
nGroups = (uint) std::max(1.0f, ceil(((float) m_triplets->pairingOffsets.get_count())/nThreads));
evt = predictOffsetMonotonizeStore.run(
m_triplets->pairingOffsets.get_mem(), m_triplets->pairingOffsets.get_count(),
range(nGroups * nThreads),
range(nThreads));
TripletThetaPhiPredictor::events.push_back(evt);
LOG << "done" << std::endl;
if(PROLIX){
PLOG << "Fetching triplet candidates...";
std::vector<uint2> cands = m_triplets->getPairings();
PLOG <<"done[" << cands.size() << "]" << std::endl;
PLOG << "Candidates:" << std::endl;
for(uint i = 0; i < nFoundTripletCandidates; ++i){
PLOG << "[" << i << "] " << cands[i].x << "-" << cands[i].y << std::endl;
}
PLOG << "Fetching candidates offets...";
std::vector<uint> candOffsets = m_triplets->getPairingOffsets();
PLOG <<"done[" << candOffsets.size() << "]" << std::endl;
PLOG << "Candidate Offsets:" << std::endl;
for(uint i = 0; i < candOffsets.size(); ++i){
PLOG << "[" << i << "] " << candOffsets[i] << std::endl;
}
}
return m_triplets;
}
Boundary Alien::getBoundary() const
{
return Boundary(getPosition() + Point(-10, -5), getPosition() + Point(10, 5));
}
static constexpr Boundary CreateFlow(float q) {
return Boundary(BoundaryType::Flow, q);
}
#include <cmath>
#include <cassert>
#include <climits>
#include <utils/common/MsgHandler.h>
#include <utils/common/ToString.h>
#include <utils/geom/GeomHelper.h>
#include <utils/options/OptionsCont.h>
#include <utils/iodevices/OutputDevice.h>
#include "GeoConvHelper.h"
// ===========================================================================
// static member variables
// ===========================================================================
GeoConvHelper GeoConvHelper::myProcessing("!", Position(), Boundary(), Boundary());
GeoConvHelper GeoConvHelper::myLoaded("!", Position(), Boundary(), Boundary());
GeoConvHelper GeoConvHelper::myFinal("!", Position(), Boundary(), Boundary());
int GeoConvHelper::myNumLoaded = 0;
// ===========================================================================
// method definitions
// ===========================================================================
GeoConvHelper::GeoConvHelper(const std::string& proj, const Position& offset,
const Boundary& orig, const Boundary& conv, double scale, double rot, bool inverse, bool flatten):
myProjString(proj),
#ifdef PROJ_API_FILE
myProjection(nullptr),
myInverseProjection(nullptr),
myGeoProjection(nullptr),
QP1Builder::QP1Builder() :
RandomFunctorBuilder(Boundary(0, inf, 0, inf))
{
}
static constexpr Boundary CreateConvection(float alpha, float envTemp) {
return Boundary(BoundaryType::Convection, alpha, envTemp);
}
W2Builder::W2Builder() :
RandomFunctorBuilder(Boundary(0.0, 1.0, -inf, inf))
{
this->dC[0] = 0.5;
this->dx0[0] = 1.0;
}
return ret;
}
template<> const RGBColor invalid_return<RGBColor>::value = RGBColor();
template<> const std::string invalid_return<RGBColor>::type = "color";
template<>
RGBColor SUMOSAXAttributes::getInternal(const int /* attr */) const {
return getColor();
}
template<> const PositionVector invalid_return<PositionVector>::value = PositionVector();
template<> const std::string invalid_return<PositionVector>::type = "PositionVector";
template<>
PositionVector SUMOSAXAttributes::getInternal(const int attr) const {
return getShape(attr);
}
template<> const Boundary invalid_return<Boundary>::value = Boundary();
template<> const std::string invalid_return<Boundary>::type = "Boundary";
template<>
Boundary SUMOSAXAttributes::getInternal(const int attr) const {
return getBoundary(attr);
}
/****************************************************************************/
void
FMultiGrid::set_bc (int * mg_bc)
{
BL_ASSERT(!m_bc.initilized);
m_bc = Boundary(mg_bc);
}
int
main(int argc, char **argv) {
OptionsCont &oc = OptionsCont::getOptions();
oc.setApplicationDescription("Importer of polygons and POIs for the road traffic simulation SUMO.");
oc.setApplicationName("polyconvert", "SUMO polyconvert Version " + (std::string)VERSION_STRING);
int ret = 0;
try {
// initialise subsystems
XMLSubSys::init(false);
fillOptions();
OptionsIO::getOptions(true, argc, argv);
if (oc.processMetaOptions(argc < 2)) {
SystemFrame::close();
return 0;
}
MsgHandler::initOutputOptions();
// build the projection
Boundary origNetBoundary, pruningBoundary;
Position2D netOffset;
std::string proj;
PCNetProjectionLoader::loadIfSet(oc, netOffset, origNetBoundary, pruningBoundary, proj);
if (proj != "") {
if (oc.isDefault("proj")) {
oc.set("proj", proj);
}
if (oc.isDefault("x-offset-to-apply")) {
oc.set("x-offset-to-apply", toString(netOffset.x()));
}
if (oc.isDefault("y-offset-to-apply")) {
oc.set("y-offset-to-apply", toString(netOffset.y()));
}
}
#ifdef HAVE_PROJ
unsigned numProjections = oc.getBool("proj.simple") + oc.getBool("proj.utm") + oc.getBool("proj.dhdn") + (oc.getString("proj").length() > 1);
if ((oc.isSet("osm-files") || oc.isSet("dlr-navteq-poly-files") || oc.isSet("dlr-navteq-poi-files")) && numProjections == 0) {
oc.set("proj.utm", true);
}
if ((oc.isSet("dlr-navteq-poly-files") || oc.isSet("dlr-navteq-poi-files")) && oc.isDefault("proj.shift")) {
oc.set("proj.shift", std::string("5"));
}
#endif
if (!GeoConvHelper::init(oc)) {
throw ProcessError("Could not build projection!");
}
// check whether the input shall be pruned
bool prune = false;
if (oc.getBool("prune.on-net")) {
if (!oc.isSet("net")) {
throw ProcessError("In order to prune the input on the net, you have to supply a network.");
}
bool ok = true;
// !!! no proper error handling
Boundary offsets = GeomConvHelper::parseBoundaryReporting(oc.getString("prune.on-net.offsets"), "--prune.on-net.offsets", 0, ok);
pruningBoundary = Boundary(
pruningBoundary.xmin()+offsets.xmin(),
pruningBoundary.ymin()+offsets.ymin(),
pruningBoundary.xmax()+offsets.xmax(),
pruningBoundary.ymax()+offsets.ymax());
prune = true;
}
if (oc.isSet("prune.boundary")) {
bool ok = true;
// !!! no proper error handling
pruningBoundary = GeomConvHelper::parseBoundaryReporting(oc.getString("prune.boundary"), "--prune.boundary", 0, ok);
prune = true;
}
PCPolyContainer toFill(prune, pruningBoundary, oc.getStringVector("remove"));
// read in the type defaults
PCTypeMap tm;
if (oc.isSet("typemap")) {
PCTypeDefHandler handler(oc, tm);
if (!XMLSubSys::runParser(handler, oc.getString("typemap"))) {
// something failed
throw ProcessError();
}
}
// read in the data
PCLoaderXML::loadIfSet(oc, toFill, tm); // SUMO-XML
PCLoaderOSM::loadIfSet(oc, toFill, tm); // OSM-XML
PCLoaderDlrNavteq::loadIfSet(oc, toFill, tm); // Elmar-files
PCLoaderVisum::loadIfSet(oc, toFill, tm); // VISUM
PCLoaderArcView::loadIfSet(oc, toFill, tm); // shape-files
// check whether any errors occured
if (!MsgHandler::getErrorInstance()->wasInformed()) {
// no? ok, save
toFill.save(oc.getString("output"));
} else {
throw ProcessError();
}
} catch (ProcessError &e) {
if (std::string(e.what())!=std::string("Process Error") && std::string(e.what())!=std::string("")) {
MsgHandler::getErrorInstance()->inform(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
#ifndef _DEBUG
} catch (...) {
MsgHandler::getErrorInstance()->inform("Quitting (on unknown error).", false);
ret = 1;
#endif
}
SystemFrame::close();
// report about ending
if (ret==0) {
std::cout << "Success." << std::endl;
}
return ret;
}
cl_ulong GridBuilder::run(HitCollection & hits, uint nThreads, const EventSupplement & eventSupplement, const LayerSupplement & layerSupplement, Grid & grid)
{
//store buffers to input data
cl_mem x = hits.transfer.buffer(GlobalX()); cl_mem y = hits.transfer.buffer(GlobalY()); cl_mem z = hits.transfer.buffer(GlobalZ());
cl_mem layer= hits.transfer.buffer(DetectorLayer()); cl_mem detId = hits.transfer.buffer(DetectorId()); cl_mem hitId = hits.transfer.buffer(HitId()); cl_mem evtId = hits.transfer.buffer(EventNumber());
cl_event evt;
local_param localMem(sizeof(cl_uint), (grid.config.nSectorsZ+1)*(grid.config.nSectorsPhi+1));
if(localMem < ctx.getLocalMemSize()){
LOG << "Grid count kernel with local memory" << std::endl;
evt = gridCount.run(
//configuration
eventSupplement.transfer.buffer(Offset()), layerSupplement.transfer.buffer(NHits()), layerSupplement.transfer.buffer(Offset()), layerSupplement.nLayers,
//grid data
grid.transfer.buffer(Boundary()),
//grid configuration
grid.config.MIN_Z, grid.config.sectorSizeZ(), grid.config.nSectorsZ,
grid.config.MIN_PHI, grid.config.sectorSizePhi(),grid.config.nSectorsPhi,
// hit input
x, y, z,
//local memory
localMem,
//work item config
range(nThreads,layerSupplement.nLayers, eventSupplement.nEvents),
range(nThreads,1, 1));
} else {
LOG << "Grid count kernel WITHOUT local memory" << std::endl;
evt = gridNoLocalCount.run(
//configuration
eventSupplement.transfer.buffer(Offset()), layerSupplement.transfer.buffer(NHits()), layerSupplement.transfer.buffer(Offset()), layerSupplement.nLayers,
//grid data
grid.transfer.buffer(Boundary()),
//grid configuration
grid.config.MIN_Z, grid.config.sectorSizeZ(), grid.config.nSectorsZ,
grid.config.MIN_PHI, grid.config.sectorSizePhi(),grid.config.nSectorsPhi,
// hit input
x, y, z,
//work item config
range(nThreads,layerSupplement.nLayers, eventSupplement.nEvents),
range(nThreads,1, 1));
}
GridBuilder::events.push_back(evt);
ctx.finish_default_queue();
//run prefix sum on grid boundaries
LOG << "Grid prefix kernel" << std::endl;
PrefixSum prefixSum(ctx);
evt = prefixSum.run(grid.transfer.buffer(Boundary()), grid.size(), nThreads, GridBuilder::events);
GridBuilder::events.push_back(evt);
ctx.finish_default_queue();
//download updated grid
grid.transfer.fromDevice(ctx,grid, &GridBuilder::events);
if(PROLIX){
printGrid(grid);
}
//allocate new buffers for ouput
hits.transfer.initBuffers(ctx, hits);
ctx.finish_default_queue();
if(localMem*2 < ctx.getLocalMemSize()){
LOG << "Grid store kernel with local memory" << std::endl;
evt = gridStore.run(
//configuration
eventSupplement.transfer.buffer(Offset()), layerSupplement.transfer.buffer(NHits()), layerSupplement.transfer.buffer(Offset()), grid.config.nLayers,
//grid data
grid.transfer.buffer(Boundary()),
//grid configuration
grid.config.MIN_Z, grid.config.sectorSizeZ(), grid.config.nSectorsZ,
grid.config.MIN_PHI, grid.config.sectorSizePhi(),grid.config.nSectorsPhi,
// hit input
x,y,z,
layer,detId, hitId, evtId,
// hit output
hits.transfer.buffer(GlobalX()), hits.transfer.buffer(GlobalY()), hits.transfer.buffer(GlobalZ()),
hits.transfer.buffer(DetectorLayer()), hits.transfer.buffer(DetectorId()), hits.transfer.buffer(HitId()), hits.transfer.buffer(EventNumber()),
//local params
localMem, localMem,
//work item config
range(nThreads,layerSupplement.nLayers, eventSupplement.nEvents),
range(nThreads,1, 1));
} else if(localMem < ctx.getLocalMemSize()){
LOG << "Grid store kernel with only local WRITTEN memory" << std::endl;
evt = gridWrittenLocalStore.run(
//configuration
eventSupplement.transfer.buffer(Offset()), layerSupplement.transfer.buffer(NHits()), layerSupplement.transfer.buffer(Offset()), grid.config.nLayers,
//grid data
grid.transfer.buffer(Boundary()),
//grid configuration
grid.config.MIN_Z, grid.config.sectorSizeZ(), grid.config.nSectorsZ,
grid.config.MIN_PHI, grid.config.sectorSizePhi(),grid.config.nSectorsPhi,
// hit input
x,y,z,
layer,detId, hitId, evtId,
// hit output
hits.transfer.buffer(GlobalX()), hits.transfer.buffer(GlobalY()), hits.transfer.buffer(GlobalZ()),
hits.transfer.buffer(DetectorLayer()), hits.transfer.buffer(DetectorId()), hits.transfer.buffer(HitId()), hits.transfer.buffer(EventNumber()),
//local params
localMem,
//work item config
range(nThreads,layerSupplement.nLayers, eventSupplement.nEvents),
range(nThreads,1, 1));
} else {
LOG << "Grid store kernel WITHOUT local memory" << std::endl;
LOG << "\tInitializing written buffer...";
clever::vector<uint, 1> m_written(0, grid.size(), ctx);
LOG << "done[" << m_written.get_count() << "]" << std::endl;
evt = gridNoLocalStore.run(
//configuration
eventSupplement.transfer.buffer(Offset()), layerSupplement.transfer.buffer(NHits()), layerSupplement.transfer.buffer(Offset()), grid.config.nLayers,
//grid data
grid.transfer.buffer(Boundary()),
//grid configuration
grid.config.MIN_Z, grid.config.sectorSizeZ(), grid.config.nSectorsZ,
grid.config.MIN_PHI, grid.config.sectorSizePhi(),grid.config.nSectorsPhi,
// hit input
x,y,z,
layer,detId, hitId, evtId,
// hit output
hits.transfer.buffer(GlobalX()), hits.transfer.buffer(GlobalY()), hits.transfer.buffer(GlobalZ()),
hits.transfer.buffer(DetectorLayer()), hits.transfer.buffer(DetectorId()), hits.transfer.buffer(HitId()), hits.transfer.buffer(EventNumber()),
//global written
m_written.get_mem(),
//work item config
range(nThreads,layerSupplement.nLayers, eventSupplement.nEvents),
range(nThreads,1, 1));
}
GridBuilder::events.push_back(evt);
ctx.finish_default_queue();
//download updated hit data and grid
//grid.transfer.fromDevice(ctx,grid, &events);
//printGrid(grid);
hits.transfer.fromDevice(ctx,hits, &GridBuilder::events);
if(PROLIX)
verifyGrid(hits, grid);
//delete old buffers
ctx.release_buffer(x); ctx.release_buffer(y); ctx.release_buffer(z);
ctx.release_buffer(layer); ctx.release_buffer(detId); ctx.release_buffer(hitId); ctx.release_buffer(evtId);
return 0;
}
// ===========================================================================
// method definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// static methods (interface in this case)
// ---------------------------------------------------------------------------
void
NIImporter_OpenDrive::loadNetwork(const OptionsCont &oc, NBNetBuilder &nb) {
// check whether the option is set (properly)
if (!oc.isUsableFileList("opendrive")) {
return;
}
// build the handler
std::vector<OpenDriveEdge> innerEdges, outerEdges;
NIImporter_OpenDrive handler(nb.getNodeCont(), innerEdges, outerEdges);
// parse file(s)
std::vector<std::string> files = oc.getStringVector("opendrive");
for (std::vector<std::string>::const_iterator file=files.begin(); file!=files.end(); ++file) {
if (!FileHelpers::exists(*file)) {
MsgHandler::getErrorInstance()->inform("Could not open opendrive file '" + *file + "'.");
return;
}
handler.setFileName(*file);
MsgHandler::getMessageInstance()->beginProcessMsg("Parsing opendrive from '" + *file + "'...");
XMLSubSys::runParser(handler, *file);
MsgHandler::getMessageInstance()->endProcessMsg("done.");
}
// convert geometries into a discretised representation
computeShapes(innerEdges);
computeShapes(outerEdges);
// -------------------------
// node building
// -------------------------
// build nodes#1
// look at all links which belong to a node, collect their bounding boxes
// and place the node in the middle of this bounding box
std::map<std::string, Boundary> posMap;
std::map<std::string, std::string> edge2junction;
// compute node positions
for (std::vector<OpenDriveEdge>::iterator i=innerEdges.begin(); i!=innerEdges.end(); ++i) {
OpenDriveEdge &e = *i;
assert(e.junction!="-1" && e.junction!="");
edge2junction[e.id] = e.junction;
if (posMap.find(e.junction)==posMap.end()) {
posMap[e.junction] = Boundary();
}
posMap[e.junction].add(e.geom.getBoxBoundary());
}
// build nodes
for (std::map<std::string, Boundary>::iterator i=posMap.begin(); i!=posMap.end(); ++i) {
if (!nb.getNodeCont().insert((*i).first, (*i).second.getCenter())) {
throw ProcessError("Could not add node '" + (*i).first + "'.");
}
}
// assign built nodes
for (std::vector<OpenDriveEdge>::iterator i=outerEdges.begin(); i!=outerEdges.end(); ++i) {
OpenDriveEdge &e = *i;
for (std::vector<OpenDriveLink>::iterator j=e.links.begin(); j!=e.links.end(); ++j) {
OpenDriveLink &l = *j;
if (l.elementType!=OPENDRIVE_ET_ROAD) {
// set node information
setNodeSecure(nb.getNodeCont(), e, l.elementID, l.linkType);
continue;
}
if (edge2junction.find(l.elementID)!=edge2junction.end()) {
// set node information of an internal road
setNodeSecure(nb.getNodeCont(), e, edge2junction[l.elementID], l.linkType);
continue;
}
}
}
// we should now have all nodes set for links which are not outer edge-to-outer edge links
// build nodes#2
// build nodes for all outer edge-to-outer edge connections
for (std::vector<OpenDriveEdge>::iterator i=outerEdges.begin(); i!=outerEdges.end(); ++i) {
OpenDriveEdge &e = *i;
for (std::vector<OpenDriveLink>::iterator j=e.links.begin(); j!=e.links.end(); ++j) {
OpenDriveLink &l = *j;
if (l.elementType!=OPENDRIVE_ET_ROAD || edge2junction.find(l.elementID)!=edge2junction.end()) {
// is a connection to an internal edge, or a node, skip
continue;
}
// we have a direct connection between to external edges
std::string id1 = e.id;
std::string id2 = l.elementID;
if (id1<id2) {
std::swap(id1, id2);
}
std::string nid = id1+"."+id2;
if (nb.getNodeCont().retrieve(nid)==0) {
// not yet seen, build
Position2D pos = l.linkType==OPENDRIVE_LT_SUCCESSOR ? e.geom[(int)e.geom.size()-1] : e.geom[0];
if (!nb.getNodeCont().insert(nid, pos)) {
throw ProcessError("Could not build node '" + nid + "'.");
}
}
/* debug-stuff
else {
Position2D pos = l.linkType==OPENDRIVE_LT_SUCCESSOR ? e.geom[e.geom.size()-1] : e.geom[0];
cout << nid << " " << pos << " " << nb.getNodeCont().retrieve(nid)->getPosition() << endl;
}
*/
setNodeSecure(nb.getNodeCont(), e, nid, l.linkType);
}
}
// we should now have start/end nodes for all outer edge-to-outer edge connections
// build nodes#3
// assign further nodes generated from inner-edges
// these nodes have not been assigned earlier, because the connectiosn are referenced in inner-edges
for (std::vector<OpenDriveEdge>::iterator i=outerEdges.begin(); i!=outerEdges.end(); ++i) {
OpenDriveEdge &e = *i;
if (e.to!=0&&e.from!=0) {
continue;
}
for (std::vector<OpenDriveEdge>::iterator j=innerEdges.begin(); j!=innerEdges.end(); ++j) {
OpenDriveEdge &ie = *j;
for (std::vector<OpenDriveLink>::iterator k=ie.links.begin(); k!=ie.links.end(); ++k) {
OpenDriveLink &il = *k;
if (il.elementType!=OPENDRIVE_ET_ROAD || il.elementID!=e.id) {
// not conneted to the currently investigated outer edge
continue;
}
std::string nid = edge2junction[ie.id];
if (il.contactPoint==OPENDRIVE_CP_START) {
setNodeSecure(nb.getNodeCont(), e, nid, OPENDRIVE_LT_PREDECESSOR);
} else {
setNodeSecure(nb.getNodeCont(), e, nid, OPENDRIVE_LT_SUCCESSOR);
}
}
}
}
//
// build start/end nodes which were not defined previously
for (std::vector<OpenDriveEdge>::iterator i=outerEdges.begin(); i!=outerEdges.end(); ++i) {
OpenDriveEdge &e = *i;
if (e.from==0) {
std::string nid = e.id + ".begin";
Position2D pos(e.geometries[0].x, e.geometries[0].y);
e.from = getOrBuildNode(nid, e.geom[0], nb.getNodeCont());
}
if (e.to==0) {
std::string nid = e.id + ".end";
Position2D pos(e.geometries[e.geometries.size()-1].x, e.geometries[e.geometries.size()-1].y);
e.to = getOrBuildNode(nid, e.geom[(int)e.geom.size()-1], nb.getNodeCont());
}
}
// -------------------------
// edge building
// -------------------------
std::map<NBEdge*, std::map<int, int> > fromLaneMap;
std::map<NBEdge*, std::map<int, int> > toLaneMap;
// build edges
for (std::vector<OpenDriveEdge>::iterator i=outerEdges.begin(); i!=outerEdges.end(); ++i) {
OpenDriveEdge &e = *i;
SUMOReal speed = nb.getTypeCont().getDefaultSpeed();
int priority = nb.getTypeCont().getDefaultPriority();
unsigned int nolanes = e.getMaxLaneNumber(SUMO_TAG_OPENDRIVE_RIGHT);
if (nolanes>0) {
NBEdge *nbe = new NBEdge("-" + e.id, e.from, e.to, "", speed, nolanes, priority, e.geom, NBEdge::LANESPREAD_RIGHT, true);
if (!nb.getEdgeCont().insert(nbe)) {
throw ProcessError("Could not add edge '" + std::string("-") + e.id + "'.");
}
fromLaneMap[nbe] = e.laneSections.back().buildLaneMapping(SUMO_TAG_OPENDRIVE_RIGHT);
toLaneMap[nbe] = e.laneSections[0].buildLaneMapping(SUMO_TAG_OPENDRIVE_RIGHT);
}
nolanes = e.getMaxLaneNumber(SUMO_TAG_OPENDRIVE_LEFT);
if (nolanes>0) {
NBEdge *nbe = new NBEdge(e.id, e.to, e.from, "", speed, nolanes, priority, e.geom.reverse(), NBEdge::LANESPREAD_RIGHT, true);
if (!nb.getEdgeCont().insert(nbe)) {
throw ProcessError("Could not add edge '" + e.id + "'.");
}
fromLaneMap[nbe] = e.laneSections[0].buildLaneMapping(SUMO_TAG_OPENDRIVE_LEFT);
toLaneMap[nbe] = e.laneSections.back().buildLaneMapping(SUMO_TAG_OPENDRIVE_LEFT);
}
}
// -------------------------
// connections building
// -------------------------
std::vector<Connection> connections;
// connections#1
// build connections between outer-edges
for (std::vector<OpenDriveEdge>::iterator i=outerEdges.begin(); i!=outerEdges.end(); ++i) {
OpenDriveEdge &e = *i;
for (std::vector<OpenDriveLink>::iterator j=e.links.begin(); j!=e.links.end(); ++j) {
OpenDriveLink &l = *j;
if (l.elementType!=OPENDRIVE_ET_ROAD) {
// we are not interested in connections to nodes
continue;
}
if (edge2junction.find(l.elementID)!=edge2junction.end()) {
// connection via an inner-road
addViaConnectionSecure(nb.getEdgeCont(),
nb.getNodeCont().retrieve(edge2junction[l.elementID]),
e, l.linkType, l.elementID, connections);
} else {
// connection between two outer-edges; can be used directly
std::vector<OpenDriveEdge>::iterator p = std::find_if(outerEdges.begin(), outerEdges.end(), edge_by_id_finder(l.elementID));
if (p==outerEdges.end()) {
throw ProcessError("Could not find connection edge.");
}
std::string id1 = e.id;
std::string id2 = (*p).id;
if (id1<id2) {
std::swap(id1, id2);
}
std::string nid = id1+"."+id2;
if (l.linkType==OPENDRIVE_LT_PREDECESSOR) {
addE2EConnectionsSecure(nb.getEdgeCont(), nb.getNodeCont().retrieve(nid), *p, e, connections);
} else {
addE2EConnectionsSecure(nb.getEdgeCont(), nb.getNodeCont().retrieve(nid), e, *p, connections);
}
}
}
}
/*
for (std::vector<OpenDriveEdge>::iterator i=innerEdges.begin(); i!=innerEdges.end(); ++i) {
OpenDriveEdge &e = *i;
std::string pred, succ;
ContactPoint predC, succC;
for (std::vector<OpenDriveLink>::iterator j=e.links.begin(); j!=e.links.end(); ++j) {
OpenDriveLink &l = *j;
if (l.elementType!=OPENDRIVE_ET_ROAD) {
// we are not interested in connections to nodes
cout << "unsupported" << endl;
continue;
}
if(edge2junction.find(l.elementID)!=edge2junction.end()) {
// not supported
cout << "unsupported" << endl;
continue;
}
if(l.linkType==OPENDRIVE_LT_SUCCESSOR) {
if(succ!="") {
cout << "double succ" << endl;
}
succ = l.elementID;
succC = l.contactPoint;
} else {
if(pred!="") {
cout << "double pred" << endl;
}
pred = l.elementID;
predC = l.contactPoint;
}
}
if(e.getMaxLaneNumber(SUMO_TAG_OPENDRIVE_LEFT)!=0&&e.getMaxLaneNumber(SUMO_TAG_OPENDRIVE_RIGHT)!=0) {
cout << "Both dirs given!" << endl;
}
bool isReversed = false;
if(e.getMaxLaneNumber(SUMO_TAG_OPENDRIVE_LEFT)!=0) {
// std::swap(pred, succ);
//std::swap(predC, succC);
isReversed = true;
}
if(succ==""||pred=="") {
cout << "Missing edge." << endl;
continue; // yes, occurs
}
NBNode *n = nb.getNodeCont().retrieve(edge2junction[e.id]);
std::vector<OpenDriveEdge>::iterator predEdge = std::find_if(outerEdges.begin(), outerEdges.end(), edge_by_id_finder(pred));
if(predEdge==outerEdges.end()) {
throw ProcessError("Could not find connection edge.");
}
std::vector<OpenDriveEdge>::iterator succEdge = std::find_if(outerEdges.begin(), outerEdges.end(), edge_by_id_finder(succ));
if(succEdge==outerEdges.end()) {
throw ProcessError("Could not find connection edge.");
}
NBEdge *fromEdge, *toEdge;
if(!isReversed) {
fromEdge = predC==OPENDRIVE_CP_END ? nb.getEdgeCont().retrieve("-" + pred) : nb.getEdgeCont().retrieve(pred);
toEdge = succC==OPENDRIVE_CP_START ? nb.getEdgeCont().retrieve("-" + succ) : nb.getEdgeCont().retrieve(succ);
} else {
fromEdge = predC!=OPENDRIVE_CP_END ? nb.getEdgeCont().retrieve("-" + pred) : nb.getEdgeCont().retrieve(pred);
toEdge = succC!=OPENDRIVE_CP_START ? nb.getEdgeCont().retrieve("-" + succ) : nb.getEdgeCont().retrieve(succ);
}
/*
Connection c(
n->hasIncoming(nb.getEdgeCont().retrieve("-" + pred)) ? nb.getEdgeCont().retrieve("-" + pred) : nb.getEdgeCont().retrieve(pred),
e.id,
n->hasOutgoing(nb.getEdgeCont().retrieve("-" + succ)) ? nb.getEdgeCont().retrieve("-" + succ) : nb.getEdgeCont().retrieve(succ));
/
Connection c(fromEdge, e.id, toEdge);
if(c.from==0||c.to==0||c.from==c.to) {
throw ProcessError("Something's false");
}
setLaneConnections(c,
*predEdge, c.from->getID()[0]!='-', c.from->getID()[0]=='-' ? SUMO_TAG_OPENDRIVE_RIGHT : SUMO_TAG_OPENDRIVE_LEFT,
e, isReversed, !isReversed ? SUMO_TAG_OPENDRIVE_RIGHT : SUMO_TAG_OPENDRIVE_LEFT,
*succEdge, c.to->getID()[0]!='-', c.to->getID()[0]=='-' ? SUMO_TAG_OPENDRIVE_RIGHT : SUMO_TAG_OPENDRIVE_LEFT);
connections.push_back(c);
}
*/
for (std::vector<Connection>::const_iterator i=connections.begin(); i!=connections.end(); ++i) {
if ((*i).from==0 || (*i).to==0) {
std::cout << "Nope." << std::endl;
continue;
}
(*i).from->addEdge2EdgeConnection((*i).to);
std::map<int, int> fromMap = fromLaneMap[(*i).from];
std::map<int, int> toMap = fromLaneMap[(*i).to];
for (std::vector<std::pair<int, int> >::const_iterator j=(*i).lanes.begin(); j!=(*i).lanes.end(); ++j) {
int fromLane = fromMap[(*j).first];
int toLane = toMap[(*j).second];
if (static_cast<unsigned int>(fromLane)>=(*i).from->getNoLanes()||fromLane<0) {
std::cout << "False " << std::endl;
}
if (static_cast<unsigned int>(toLane)>=(*i).to->getNoLanes()||toLane<0) {
std::cout << "False " << std::endl;
}
(*i).from->addLane2LaneConnection(fromLane, (*i).to, toLane, NBEdge::L2L_VALIDATED, true);
}
}
}
#include "stdafx.h"
IMPLEMENT_SERIAL(Cube, CObject, 1)
Boundary Cube::sBoundary = Boundary(sqrt(3.0f));
bool Cube::newDeviceNode()
{
bool newDevCube(DevNode***, DevNode** const root, const D3DMATERIAL9 Material);
return newDevCube(&m_devNode, m_Root ? m_Root->m_devNode : 0, m_Material);
}
Cube::Cube(Node* const root, const TCHAR* const Name, const sp Color)
: Node(root, CUBE, Name, Color)
{
if (!newDeviceNode())
exit(1);
}
Cube::Cube(const Cube& other)
: Node(other)
{
if (!newDeviceNode())
exit(1);
}
bool Cube::GetInfo(const sp& K, const sp& L, Info& info, const Info* pHint, bool fromOutSide) const
{
if (pHint && pHint->pNode == this && fromOutSide)
return false;
Pairing * PairGeneratorSector::run(HitCollection & hits, const GeometrySupplement & geomSupplement,
uint nThreads, const TripletConfigurations & layerTriplets, const Grid & grid)
{
std::vector<uint> oracleOffset;
uint totalMaxPairs = 0;
uint nLayerTriplets = layerTriplets.size();
for(uint e = 0; e < grid.config.nEvents; ++e){
for(uint p = 0; p < nLayerTriplets; ++p){
TripletConfiguration layerPair(layerTriplets, p);
LayerGrid layer1(grid, layerPair.layer1(),e);
LayerGrid layer2(grid, layerPair.layer2(),e);
uint nMaxPairs = layer1.size()*layer2.size();
nMaxPairs = 32 * std::ceil(nMaxPairs / 32.0); //round to next multiple of 32
oracleOffset.push_back(totalMaxPairs);
totalMaxPairs += nMaxPairs;
}
}
LOG << "Initializing oracle offsets for pair gen...";
clever::vector<uint, 1> m_oracleOffset(oracleOffset, ctx);
LOG << "done[" << m_oracleOffset.get_count() << "]" << std::endl;
LOG << "Initializing oracle for pair gen...";
clever::vector<uint, 1> m_oracle(0, std::ceil(totalMaxPairs / 32.0), ctx);
LOG << "done[" << m_oracle.get_count() << "]" << std::endl;
LOG << "Initializing prefix sum for pair gen...";
clever::vector<uint, 1> m_prefixSum(0, grid.config.nEvents*nLayerTriplets*nThreads+1, ctx);
LOG << "done[" << m_prefixSum.get_count() << "]" << std::endl;
//ctx.select_profile_event(KERNEL_COMPUTE_EVT());
LOG << "Running pair gen kernel...";
cl_event evt = pairCount.run(
//configuration
layerTriplets.transfer.buffer(Layer1()), layerTriplets.transfer.buffer(Layer2()), grid.config.nLayers,
grid.transfer.buffer(Boundary()),
grid.config.MIN_Z, grid.config.sectorSizeZ(), grid.config.nSectorsZ,
grid.config.MIN_PHI, grid.config.sectorSizePhi(), grid.config.nSectorsPhi,
layerTriplets.transfer.buffer(pairSpreadZ()), layerTriplets.transfer.buffer(pairSpreadPhi()),
// hit input
hits.transfer.buffer(GlobalX()), hits.transfer.buffer(GlobalY()), hits.transfer.buffer(GlobalZ()),
// intermeditate data: oracle for hit pairs, prefix sum for found pairs
m_oracle.get_mem(), m_oracleOffset.get_mem(), m_prefixSum.get_mem(),
//local
local_param(sizeof(cl_uint), (grid.config.nSectorsZ+1)*(grid.config.nSectorsPhi+1)),
//thread config
range(nThreads, nLayerTriplets, grid.config.nEvents),
range(nThreads, 1,1));
PairGeneratorSector::events.push_back(evt);
LOG << "done" << std::endl;
if(PROLIX){
PLOG << "Fetching prefix sum for pair gen...";
std::vector<uint> vPrefixSum(m_prefixSum.get_count());
transfer::download(m_prefixSum,vPrefixSum,ctx);
PLOG << "done" << std::endl;
PLOG << "Prefix sum: ";
for(auto i : vPrefixSum){
PLOG << i << " ; ";
}
PLOG << std::endl;
}
if(PROLIX){
PLOG << "Fetching oracle for pair gen...";
std::vector<uint> oracle(m_oracle.get_count());
transfer::download(m_oracle,oracle,ctx);
PLOG << "done" << std::endl;
PLOG << "Oracle: ";
for(auto i : oracle){
PLOG << i << " ; ";
}
PLOG << std::endl;
}
//Calculate prefix sum
PrefixSum prefixSum(ctx);
evt = prefixSum.run(m_prefixSum.get_mem(), m_prefixSum.get_count(), nThreads, PairGeneratorSector::events);
uint nFoundPairs;
transfer::downloadScalar(m_prefixSum, nFoundPairs, ctx, true, m_prefixSum.get_count()-1, 1, &evt);
if(PROLIX){
PLOG << "Fetching prefix sum for pair gen...";
std::vector<uint> vPrefixSum(m_prefixSum.get_count());
transfer::download(m_prefixSum,vPrefixSum,ctx);
PLOG << "done" << std::endl;
PLOG << "Prefix sum: ";
for(auto i : vPrefixSum){
PLOG << i << " ; ";
}
PLOG << std::endl;
}
LOG << "Initializing pairs...";
Pairing * hitPairs = new Pairing(ctx, nFoundPairs, grid.config.nEvents, layerTriplets.size());
LOG << "done[" << hitPairs->pairing.get_count() << "]" << std::endl;
LOG << "Running pair gen store kernel...";
evt = pairStore.run(
//configuration
layerTriplets.transfer.buffer(Layer1()), layerTriplets.transfer.buffer(Layer2()), grid.config.nLayers,
//grid
grid.transfer.buffer(Boundary()), grid.config.nSectorsZ, grid.config.nSectorsPhi,
// input for oracle and prefix sum
m_oracle.get_mem(), m_oracleOffset.get_mem(), m_prefixSum.get_mem(),
// output of pairs
hitPairs->pairing.get_mem(), hitPairs->pairingOffsets.get_mem(),
//thread config
range(nThreads, nLayerTriplets, grid.config.nEvents),
range(nThreads, 1,1));
PairGeneratorSector::events.push_back(evt);
LOG << "done" << std::endl;
if(PROLIX){
PLOG << "Fetching pairs...";
std::vector<uint2> pairs = hitPairs->getPairings();
PLOG <<"done[" << pairs.size() << "]" << std::endl;
PLOG << "Pairs:" << std::endl;
for(uint i = 0; i < nFoundPairs; ++i){
PLOG << "[" << i << "] " << pairs[i].x << "-" << pairs[i].y << std::endl;
}
PLOG << "Fetching pair offets...";
std::vector<uint> pairOffsets = hitPairs->getPairingOffsets();
PLOG <<"done[" << pairOffsets.size() << "]" << std::endl;
PLOG << "Pair Offsets:" << std::endl;
for(uint i = 0; i < pairOffsets.size(); ++i){
PLOG << "[" << i << "] " << pairOffsets[i] << std::endl;
}
}
return hitPairs;
}
Boundary PowerUp::boundary() const
{
return Boundary(x, scale);
}
