float Compass::getDirection()
{
CompassVec v = getMeasurements();
//TODO try to understand why compass measuress mirrored angle (-x coordinate compensates it)
float res = atan2(v.y, -v.x) * 180 / M_PI;
if (res < 0)
{
return res + 360;
}
return res;
}
void Compass::doCalibration() {
//This method makes no sense without serial output
while(!Serial.available());
for (;;)
{
CompassVec v = getMeasurements();
maxMeas = maxMeas.maxVec(v);
minMeas = minMeas.minVec(v);
maxMeas.print();
Serial.print(" ");
minMeas.print();
Serial.println("");
}
}
void
WeightedLoadBalancerStrategy::beforeSatisfyInterest(shared_ptr<pit::Entry> pitEntry,
const Face& inFace,
const Data& data)
{
NFD_LOG_TRACE("Received Data: " << data.getName());
auto pitInfo = pitEntry->getStrategyInfo<MyPitInfo>();
// No start time available, cannot compute delay for this retrieval
if (pitInfo == nullptr)
{
NFD_LOG_TRACE("No start time available for Data " << data.getName());
return;
}
const milliseconds delay =
duration_cast<milliseconds>(system_clock::now() - pitInfo->creationTime);
NFD_LOG_TRACE("Computed delay of: " << system_clock::now() << " - " << pitInfo->creationTime << " = " << delay);
auto& accessor = getMeasurements();
// Update Face delay measurements and entry lifetimes owned
// by this strategy while walking up the NameTree
auto measurementsEntry = accessor.get(*pitEntry);
if (measurementsEntry != nullptr)
{
NFD_LOG_TRACE("accessor returned measurements entry " << measurementsEntry->getName()
<< " for " << pitEntry->getName());
}
else
{
NFD_LOG_WARN ("accessor returned invalid measurements entry for " << pitEntry->getName());
}
while (measurementsEntry != nullptr)
{
auto measurementsEntryInfo = measurementsEntry->getStrategyInfo<MyMeasurementInfo>();
if (measurementsEntryInfo != nullptr)
{
accessor.extendLifetime(*measurementsEntry, seconds(16));
measurementsEntryInfo->updateFaceDelay(inFace, delay);
}
measurementsEntry = accessor.getParent(*measurementsEntry);
}
}
AsfStrategy::AsfStrategy(Forwarder& forwarder, const Name& name)
: Strategy(forwarder)
, m_measurements(getMeasurements())
, m_probing(m_measurements)
, m_retxSuppression(RETX_SUPPRESSION_INITIAL,
RetxSuppressionExponential::DEFAULT_MULTIPLIER,
RETX_SUPPRESSION_MAX)
{
ParsedInstanceName parsed = parseInstanceName(name);
if (!parsed.parameters.empty()) {
BOOST_THROW_EXCEPTION(std::invalid_argument("AsfStrategy does not accept parameters"));
}
if (parsed.version && *parsed.version != getStrategyName()[-1].toVersion()) {
BOOST_THROW_EXCEPTION(std::invalid_argument(
"AsfStrategy does not support version " + std::to_string(*parsed.version)));
}
this->setInstanceName(makeInstanceName(name, getStrategyName()));
}
shared_ptr<MyMeasurementInfo>
WeightedLoadBalancerStrategy::myGetOrCreateMyMeasurementInfo(const shared_ptr<fib::Entry>& entry)
{
BOOST_ASSERT(entry != nullptr);
//this could return null?
auto measurementsEntry = getMeasurements().get(*entry);
BOOST_ASSERT(measurementsEntry != nullptr);
auto measurementsEntryInfo = measurementsEntry->getStrategyInfo<MyMeasurementInfo>();
if (measurementsEntryInfo == nullptr)
{
measurementsEntryInfo = make_shared<MyMeasurementInfo>();
measurementsEntry->setStrategyInfo(measurementsEntryInfo);
}
return measurementsEntryInfo;
}
int main (int argc, char* argv[])
{
LOGOG_INITIALIZE();
logog::Cout* logog_cout (new logog::Cout);
BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter);
logog_cout->SetFormatter(*custom_format);
TCLAP::CmdLine cmd("Add EMI data as a scalar cell array to a 2d mesh.", ' ', "0.1");
// I/O params
TCLAP::ValueArg<std::string> poly_out("o", "polydata-output-file",
"the name of the file the data will be written to", true,
"", "file name of polydata file");
cmd.add(poly_out);
TCLAP::ValueArg<std::string> csv_in("i", "csv-input-file",
"csv-file containing EMI data", true,
"", "name of the csv input file");
cmd.add(csv_in);
TCLAP::ValueArg<std::string> dem_in("s", "DEM-file",
"Surface DEM for mapping ERT data", false,
"", "file name of the Surface DEM");
cmd.add(dem_in);
cmd.parse(argc, argv);
MeshLib::Mesh* mesh (nullptr);
if (dem_in.isSet())
{
mesh = FileIO::VtuInterface::readVTUFile(dem_in.getValue());
if (mesh == nullptr)
{
ERR ("Error reading mesh file.");
return -2;
}
if (mesh->getDimension() != 2)
{
ERR ("This utility can handle only 2d meshes at this point.");
delete mesh;
return -3;
}
INFO("Surface mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements());
}
GeoLib::GEOObjects geo_objects;
FileIO::XmlGmlInterface xml(geo_objects);
//std::vector<GeoLib::Polyline*> *lines = new std::vector<GeoLib::Polyline*>;
std::array<char, 2> dipol = {{ 'H', 'V' }};
std::array<char,3> const regions = {{'A', 'B', 'C'}};
for (std::size_t j=0; j<dipol.size(); ++j)
{
std::vector<GeoLib::Point*> *points = new std::vector<GeoLib::Point*>;
for (std::size_t i=0; i<regions.size(); ++i)
{
//std::size_t const start_idx (points->size());
getPointsFromFile(*points, csv_in.getValue(), dipol[j], regions[i]);
//std::size_t const end_idx (points->size());
//GeoLib::Polyline* line = new GeoLib::Polyline(*points);
//for (std::size_t j=start_idx; j<end_idx; ++j)
// line->addPoint(j);
//lines->push_back(line);
}
std::string geo_name (std::string("EMI Data ").append(1,dipol[j]));
geo_objects.addPointVec(points, geo_name);
//geo_objects.addPolylineVec(lines, geo_name);
if (mesh != nullptr)
{
GeoMapper mapper(geo_objects, geo_name);
mapper.mapOnMesh(mesh);
}
xml.setNameForExport(geo_name);
std::string const output_name = poly_out.getValue() + "_" + dipol[j] + ".gml";
xml.writeToFile(output_name);
std::vector<double> emi;
for (std::size_t i=0; i<regions.size(); ++i)
getMeasurements(emi, csv_in.getValue(), dipol[j], regions[i]);
writeMeasurementsToFile(emi, poly_out.getValue(), dipol[j]);
std::for_each(points->begin(), points->end(), std::default_delete<GeoLib::Point>());
delete points;
}
delete mesh;
delete custom_format;
delete logog_cout;
LOGOG_SHUTDOWN();
return 0;
}
