Add satellite links

Authors.md

@@ -9,6 +9,7 @@
 * Sara Metwalli
 * Michal Hadjusek
 * Makoto Nakai
+* Paolo Fittipaldi
 
 ## Senior Advisors:
 

quisp/.nedfolders

@@ -1,4 +1,4 @@
 .
-./channels
-./modules
-./networks
+channels
+modules
+networks

quisp/channels/CSVParser.cc

@@ -0,0 +1,59 @@
+/** \file CSVParser.cc
+ *
+ *  \brief CSVParser
+ *
+ *
+ *  Quick parser for CSVs, written for csv-based Free-space channels.
+ */
+
+#include "CSVParser.h"
+
+CSVParser::CSVParser(const string filename) {
+  file.open(filename);
+  if (!file.is_open()) throw cRuntimeError("Couldn't find CSV file!");
+  string line;
+  double key = 0;
+  double val = 0;
+  char sep;  // throwaway
+  while (file >> line) {
+    std::istringstream ss(line);
+    ss >> key >> sep >> val;
+    property.insert(std::pair<double, double>(key, val));
+  }
+  return;
+}
+
+double CSVParser::getPropertyAtTime(const double time) {
+  if (time < getLowestDatapoint()) return getLowestDatavalue();
+  if (time > getHighestDatapoint()) return getHighestDatavalue();
+
+  // These two first lines are there just to provide mathematically sound results.
+  // They should never be used in actual simulation, as they are NOT in any way
+  // guaranteed to be accurate.
+
+  if (time != last_polled_time) {
+    last_polled_time = time;
+    auto u_b = property.upper_bound(time);
+    if (u_b == property.end()) {
+      last_polled_value = (--u_b)->second;
+    } else if (u_b == property.begin()) {
+      last_polled_value = u_b->second;
+    } else {
+      auto l_b = u_b;
+      --l_b;
+      const double delta = (time - l_b->first) / (u_b->first - l_b->first);
+      last_polled_value = delta * u_b->second + (1 - delta) * l_b->second;
+    }
+  }
+  return last_polled_value;
+}
+
+int CSVParser::getLowestDatapoint() { return property.begin()->first; }
+
+int CSVParser::getHighestDatapoint() { return property.rbegin()->first; }
+
+double CSVParser::getLowestDatavalue() { return property.begin()->second; }
+
+double CSVParser::getHighestDatavalue() { return property.rbegin()->second; }
+
+CSVParser::~CSVParser() {}

quisp/channels/CSVParser.h

@@ -0,0 +1,41 @@
+/*
+ * CSVParser.h
+ *
+ *  Created on: Nov 28, 2023
+ *      Author: paolo
+ */
+
+#ifndef CHANNELS_CSVPARSER_H_
+#define CHANNELS_CSVPARSER_H_
+
+#include <omnetpp.h>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <sstream>
+
+using namespace omnetpp;
+using std::string;
+
+class CSVParser {
+ public:
+  CSVParser();
+  CSVParser(const string filename);
+  virtual ~CSVParser();
+  double getPropertyAtTime(const double time);
+  int getLowestDatapoint();
+  int getHighestDatapoint();
+  double getLowestDatavalue();
+  double getHighestDatavalue();
+
+  char* getName;
+
+ private:
+  std::ifstream file;
+  char* name;
+  double last_polled_time = -1;
+  double last_polled_value = -1;
+  std::map<double, double> property;
+};
+
+#endif /* CHANNELS_CSVPARSER_H_ */

quisp/channels/CSVParser_test.cc

@@ -0,0 +1,56 @@
+#include <gtest/gtest.h>
+
+#include <test_utils/TestUtils.h>
+
+#include <fstream>
+
+#include "CSVParser.h"
+
+#include <cstdio>
+
+using namespace quisp_test;
+using namespace quisp_test::utils;
+using namespace quisp::messages;
+using namespace quisp::modules::SharedResource;
+
+namespace {
+
+class CSVParserTest : public ::testing::Test {
+ protected:
+  void SetUp() {
+    csv_to_generate.open("channels/test_csv.csv");
+    csv_to_generate << "200,100000\n";
+    csv_to_generate << "300,300000\n";
+    csv_to_generate << "400,200000\n";
+    csv_to_generate.close();
+    csv_parser = new CSVParser("channels/test_csv.csv");
+  }
+  void TearDown() { std::remove("channels/test_csv.csv"); }
+
+  CSVParser* csv_parser;
+  std::ofstream csv_to_generate;
+};
+
+TEST_F(CSVParserTest, lowerBound) {
+  ASSERT_DOUBLE_EQ(csv_parser->getLowestDatapoint(), 200);
+  ASSERT_DOUBLE_EQ(csv_parser->getLowestDatavalue(), 100000);
+}
+
+TEST_F(CSVParserTest, upperBound) {
+  ASSERT_DOUBLE_EQ(csv_parser->getHighestDatapoint(), 400);
+  ASSERT_DOUBLE_EQ(csv_parser->getHighestDatavalue(), 200000);
+}
+
+TEST_F(CSVParserTest, lowerThanLB) { ASSERT_DOUBLE_EQ(csv_parser->getPropertyAtTime(100), 100000); }
+
+TEST_F(CSVParserTest, higherThanUB) { ASSERT_DOUBLE_EQ(csv_parser->getPropertyAtTime(500), 200000); }
+
+TEST_F(CSVParserTest, normalOperation) {
+  ASSERT_DOUBLE_EQ(csv_parser->getPropertyAtTime(250), 200000);
+  ASSERT_DOUBLE_EQ(csv_parser->getPropertyAtTime(300), 300000);
+  ASSERT_DOUBLE_EQ(csv_parser->getPropertyAtTime(350), 250000);
+  ASSERT_DOUBLE_EQ(csv_parser->getPropertyAtTime(234.5), 169000);
+  ASSERT_DOUBLE_EQ(csv_parser->getPropertyAtTime(287.4), 274800);
+}
+
+}  // namespace

quisp/channels/FSChannel.cc

@@ -0,0 +1,68 @@
+/** \file FSChannel.cc
+ *
+ *  \brief Freespace channel
+ *
+ *
+ */
+
+#include "FSChannel.h"
+
+using namespace omnetpp;
+namespace quisp::channels {
+
+FSChannel::FSChannel(){};
+
+Define_Channel(FSChannel);
+
+void FSChannel::initialize() {
+  cDatarateChannel::initialize();
+  const char *filename = par("distance_CSV").stringValue();
+  dist_par = new CSVParser(filename);
+  op.orbit_period = par("orbital_period");
+  op.vis_start_time = dist_par->getLowestDatapoint();
+  op.vis_end_time = dist_par->getHighestDatapoint();
+}
+
+cChannel::Result FSChannel::processMessage(cMessage *msg, const SendOptions &options, simtime_t t) {
+  Result result;
+
+  if (!checkLOS() and !dynamic_cast<OspfPacket *>(msg)) {
+    result.discard = true;
+  } else {
+    recalculateChannelParameters();
+    result = cDatarateChannel::processMessage(msg, options, t);
+  }
+  return result;
+}
+
+bool FSChannel::checkLOS() {
+  Enter_Method("checkLOS()");
+  const SimTime currentTime = fmod(simTime(), op.orbit_period);
+  if (currentTime >= op.vis_start_time and currentTime <= op.vis_end_time) {
+    return true;
+  }
+  return false;
+}
+
+double FSChannel::getDistanceAtTime(const simtime_t time) {
+  recalculateChannelParameters();
+  return dist_par->getPropertyAtTime(time.dbl());
+}
+
+SimTime FSChannel::getNext_check_time() {
+  Enter_Method("next_check_time()");
+  const SimTime current_time = fmod(simTime(), op.orbit_period);
+  if (current_time >= op.vis_start_time and current_time <= op.vis_end_time) {
+    return 0;
+  }
+  if (current_time >= op.vis_end_time) {  // Satellite already passed for this orbit
+    return op.vis_start_time + op.orbit_period - current_time;
+  }
+  return op.vis_start_time - current_time;
+}
+
+void FSChannel::recalculateChannelParameters() {
+  par("distance").setDoubleValue(dist_par->getPropertyAtTime(simTime().dbl()));
+  if (par("CSV_varies_delay").boolValue()) par("delay").setDoubleValue(par("distance").doubleValue() / par("speed_of_light_in_FS").doubleValue());
+}
+}  // namespace quisp::channels

quisp/channels/FSChannel.h

@@ -0,0 +1,51 @@
+/** \file FSChannel.h
+ *
+ *  \brief Freespace channel
+ *
+ *  Loss model from 10.1038/s42005-022-01123-7.
+ *  Base class for Free-space communication: this channel handles variable length and delay using a CSVParser.
+ *  LOS-related methods are directly callable from outside since the pointing system is expected to be able to directly check whether there is visibility or not.
+ *
+ */
+
+#ifndef CHANNELS_FSCHANNEL_H_
+#define CHANNELS_FSCHANNEL_H_
+
+#include <messages/ospf_messages_m.h>
+#include <omnetpp.h>
+#include <cmath>
+#include <stdexcept>
+#include "CSVParser.h"
+#include "PhotonicQubit_m.h"
+#include "omnetpp/cexception.h"
+
+using namespace omnetpp;
+using namespace quisp::messages;
+
+struct ORBITAL_PARAMETERS {
+  SimTime orbit_period = SIMTIME_MAX;
+  SimTime vis_start_time = SIMTIME_ZERO;
+  SimTime vis_end_time = SIMTIME_MAX;
+};
+
+namespace quisp::channels {
+class FSChannel : public cDatarateChannel {
+ public:
+  FSChannel();
+  virtual void initialize() override;
+  void set_orbit_parameters(double orb_period, double orb_vis_start_coeff, double orb_vis_end_coeff);
+  virtual void recalculateChannelParameters();
+  bool checkLOS();
+  double getDistanceAtTime(const simtime_t time);
+  virtual SimTime getNext_check_time();
+
+ private:
+  ORBITAL_PARAMETERS op;
+  CSVParser *dist_par;
+
+ protected:
+  cChannel::Result processMessage(cMessage *msg, const SendOptions &options, simtime_t t) override;
+};
+};  // namespace quisp::channels
+
+#endif /* CHANNELS_FSCHANNEL_H_ */