/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#include "resonant-charger-helper.h"

#include "ns3/resonant-charger-energy-model.h"

namespace ns3 {

ResonantChargerHelper::ResonantChargerHelper ()

{

}

DeviceEnergyModelContainer

ResonantChargerHelper::Install (NodeContainer c) const

{

  DeviceEnergyModelContainer tmp;

  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)

    {

      tmp.Add (Install (*i));

    }

  return tmp;

}

Ptr<DeviceEnergyModel>

ResonantChargerHelper::Install (std::string nodeName) const

{

  Ptr<Node> node = Names::Find<Node> (nodeName);

  return Install (node);

}

Ptr<DeviceEnergyModel>

ResonantChargerHelper::Install (Ptr<Node> node) const

{

  NS_ASSERT (node != NULL);

  Ptr<ResonantChargerEnergyModel> resonantChargerEnergyModel = CreateObject<ResonantChargerEnergyModel> ();

  Ptr<EnergySource> energySource = node->GetObject<EnergySourceContainer> ()->Get (0);

  NS_ASSERT (energySource != NULL);

  resonantChargerEnergyModel->SetEnergySource (energySource);

  energySource->AppendDeviceEnergyModel (resonantChargerEnergyModel);

  resonantChargerEnergyModel->SetNode (node);

  return resonantChargerEnergyModel;

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#ifndef RESONANT_CHARGER_HELPER_H

#define RESONANT_CHARGER_HELPER_H

#include "ns3/names.h"

#include "ns3/node-container.h"

#include "ns3/object-factory.h"

#include "ns3/device-energy-model.h"

#include "ns3/device-energy-model-container.h"

namespace ns3 {

/**

 * \ingroup energy

 * Install into a node (or set of nodes) the resonant charger energy model

 */

class ResonantChargerHelper

{

public:

  ResonantChargerHelper ();

  /**

   * Install the resonant charger energy model into a set of nodes.

   * 

   * \param c NodeContainer where to install.

   * 

   * \returns DeviceEnergyModelContainer.

   */

  DeviceEnergyModelContainer Install (NodeContainer c) const;

  /**

   * Install the resonant charger energy model into a single node.

   *

   * \param nodeName Name of the node where to install.

   * 

   * \returns a pointer to DeviceEnergyModel.

   */

  Ptr<DeviceEnergyModel> Install (std::string nodeName) const;

  /**

   * Install the resonant charger energy model into a single node.

   *

   * \param node Pointer of the node where to install.

   * 

   * \returns a pointer to DeviceEnergyModel.

   */

  Ptr<DeviceEnergyModel> Install (Ptr<Node> node) const;

};

} // namespace ns3

#endif /* RESONANT_CHARGER_HELPER_H */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#include "resonant-energy-harvester-helper.h"

#include "ns3/resonant-energy-harvester.h"

namespace ns3 {

ResonantEnergyHarvesterHelper::ResonantEnergyHarvesterHelper ()

{

  m_resonantEnergyHarvester.SetTypeId ("ns3::ResonantEnergyHarvester");

}

ResonantEnergyHarvesterHelper::~ResonantEnergyHarvesterHelper ()

{

}

void

ResonantEnergyHarvesterHelper::Set (std::string name, const AttributeValue &v)

{

  m_resonantEnergyHarvester.Set (name, v);

}

Ptr<EnergyHarvester>

ResonantEnergyHarvesterHelper::DoInstall (Ptr<EnergySource> source) const

{

  NS_ASSERT (source != NULL);

  Ptr<Node> node = source->GetNode ();

  // Create a new Basic Energy Harvester

  Ptr<EnergyHarvester> harvester = m_resonantEnergyHarvester.Create<EnergyHarvester> ();

  NS_ASSERT (harvester != NULL);

  // Connect the Basic Energy Harvester to the Energy Source

  source->ConnectEnergyHarvester (harvester);

  harvester->SetNode (node);

  harvester->SetEnergySource (source);

  return harvester;

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#ifndef RESONANT_ENERGY_HARVESTER_HELPER_H

#define RESONANT_ENERGY_HARVESTER_HELPER_H

#include "ns3/energy-harvester-helper.h"

#include "ns3/energy-source.h"

namespace ns3 {

/**

 * \ingroup energy

 * \brief Creates a ResonantEnergyHarvester object.

 */

class ResonantEnergyHarvesterHelper : public EnergyHarvesterHelper

{

public:

  ResonantEnergyHarvesterHelper ();

  ~ResonantEnergyHarvesterHelper ();

  void Set (std::string name, const AttributeValue &v);

private:

  virtual Ptr<EnergyHarvester> DoInstall (Ptr<EnergySource> source) const;

private:

  ObjectFactory m_resonantEnergyHarvester;

};

} // namespace ns3

#endif /* defined(RESONANT_ENERGY_HARVESTER_HELPER_H) */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#include "solar-energy-harvester-helper.h"

#include "ns3/solar-energy-harvester.h"

namespace ns3 {

SolarEnergyHarvesterHelper::SolarEnergyHarvesterHelper ()

{

  m_solarEnergyHarvester.SetTypeId ("ns3::SolarEnergyHarvester");

}

SolarEnergyHarvesterHelper::~SolarEnergyHarvesterHelper ()

{

}

void

SolarEnergyHarvesterHelper::Set (std::string name, const AttributeValue &v)

{

  m_solarEnergyHarvester.Set (name, v);

}

Ptr<EnergyHarvester>

SolarEnergyHarvesterHelper::DoInstall (Ptr<EnergySource> source) const

{

  NS_ASSERT (source != NULL);

  Ptr<Node> node = source->GetNode ();

  // Create a new Basic Energy Harvester

  Ptr<EnergyHarvester> harvester = m_solarEnergyHarvester.Create<EnergyHarvester> ();

  NS_ASSERT (harvester != NULL);

  // Connect the Basic Energy Harvester to the Energy Source

  source->ConnectEnergyHarvester (harvester);

  harvester->SetNode (node);

  harvester->SetEnergySource (source);

  return harvester;

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#ifndef SOLAR_ENERGY_HARVESTER_HELPER_H

#define SOLAR_ENERGY_HARVESTER_HELPER_H

#include "ns3/energy-harvester-helper.h"

#include "ns3/energy-source.h"

namespace ns3 {

/**

 * \ingroup energy

 * \brief Creates a SolarEnergyHarvester object.

 */

class SolarEnergyHarvesterHelper : public EnergyHarvesterHelper

{

public:

  SolarEnergyHarvesterHelper ();

  ~SolarEnergyHarvesterHelper ();

  void Set (std::string name, const AttributeValue &v);

private:

  virtual Ptr<EnergyHarvester> DoInstall (Ptr<EnergySource> source) const;

private:

  ObjectFactory m_solarEnergyHarvester;

};

} // namespace ns3

#endif /* defined(SOLAR_ENERGY_HARVESTER_HELPER_H) */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#include "resonant-charger-energy-model.h"

#include "ns3/mobility-model.h"

#include "ns3/energy-harvester-container.h"

#include "ns3/resonant-energy-harvester.h"

#include "src/core/model/callback.h"

NS_LOG_COMPONENT_DEFINE ("ResonantChargerEnergyModel");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (ResonantChargerEnergyModel);

TypeId

ResonantChargerEnergyModel::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::ResonantChargerEnergyModel")

    .SetParent<DeviceEnergyModel> ()

    .AddConstructor<ResonantChargerEnergyModel> ()

    .AddAttribute ("ResonantCharger Power Consumption",

                   "Consumed power by the Resonant Charger",

                   DoubleValue (51.0),

                   MakeDoubleAccessor (&ResonantChargerEnergyModel::m_resonatorPowerRate),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("Power Loss Per Distance",

                   "The power loss per unit distance",

                   DoubleValue (20.4),

                   MakeDoubleAccessor (&ResonantChargerEnergyModel::m_powerLossPerDistance),

                   MakeDoubleChecker<double> ())

    //The energy loss per unit distance

  ;

  return tid;

}

ResonantChargerEnergyModel::ResonantChargerEnergyModel ()

  : m_node (NULL),

    m_source (NULL),

    m_lastUpdateTime (Simulator::Now ()),

    m_state (OFF)

{

  NS_LOG_FUNCTION (this);

  m_energyDepletionCallback.Nullify ();

  m_energyRechargeCallback.Nullify ();

}

ResonantChargerEnergyModel::~ResonantChargerEnergyModel ()

{

  m_energyDepletionCallback.Nullify ();

  m_energyRechargeCallback.Nullify ();

  m_node = NULL;

  m_source = NULL;

}

void

ResonantChargerEnergyModel::SetNode (Ptr<Node> node)

{

  NS_LOG_FUNCTION (this << node);

  NS_ASSERT (node != NULL);

  m_node = node;

  Charge ();

}

Ptr<Node>

ResonantChargerEnergyModel::GetNode (void) const

{

  return m_node;

}

void

ResonantChargerEnergyModel::SetEnergySource (Ptr<EnergySource> source)

{

  NS_LOG_FUNCTION (this << source);

  NS_ASSERT (source != NULL);

  m_source = source;

}

double

ResonantChargerEnergyModel::GetTotalEnergyConsumption (void) const

{

  NS_LOG_FUNCTION (this);

  return m_totalEnergyConsumption;

}

void

ResonantChargerEnergyModel::ChangeState (int newState)

{

}

void

ResonantChargerEnergyModel::SetState (State state)

{

  NS_LOG_FUNCTION (this);

  if (m_state != DISABLED)

    {

      m_state = state;

    }

}

ResonantChargerEnergyModel::State

ResonantChargerEnergyModel::GetState ()

{

  NS_LOG_FUNCTION (this);

  return m_state;

}

void

ResonantChargerEnergyModel::ChangeEnergyConsumption ()

{

  Time duration = Simulator::Now () - m_lastUpdateTime;

  NS_ASSERT (duration.GetNanoSeconds () >= 0); // check if duration is valid

  double energyToDecrease = duration.GetSeconds () * m_resonatorPowerRate;

  // charger is not active

  if(m_state == OFF || m_state == DISABLED)

    {

      energyToDecrease = 0;

    }

  // update total energy consumption

  m_totalEnergyConsumption += energyToDecrease;

  // update current drain

  double supplyVoltage = m_source->GetSupplyVoltage ();

  m_actualCurrentDrain = m_resonatorPowerRate / supplyVoltage;

  // update last update time stamp

  m_lastUpdateTime = Simulator::Now ();

  // notify energy source

  m_source->UpdateEnergySource ();

  // some debug message

  NS_LOG_DEBUG ("ResonantChargerEnergyModel:Total energy consumption at node #" <<

                m_node->GetId () << " is " << m_totalEnergyConsumption << "J");

}

void

ResonantChargerEnergyModel::SetEnergyDepletionCallback (ResonantChargerEnergyDepletionCallback callback)

{

  NS_LOG_FUNCTION (this);

  if (callback.IsNull ())

    {

      NS_LOG_DEBUG ("ResonantChargerEnergyModel:Setting NULL energy depletion callback!");

    }

  m_energyDepletionCallback = callback;

}

void

ResonantChargerEnergyModel::SetEnergyRechargeCallback (ResonantChargerEnergyRechargeCallback callback)

{

  NS_LOG_FUNCTION (this);

  if (callback.IsNull ())

    {

      NS_LOG_DEBUG ("ResonantChargerEnergyModel:Setting NULL energy recharge callback!");

    }

  m_energyRechargeCallback = callback;

}

void

ResonantChargerEnergyModel::HandleEnergyDepletion (void)

{

  NS_LOG_FUNCTION (this);

  NS_LOG_DEBUG ("ResonantChargerEnergyModel:Energy is depleted at node #" <<

                m_node->GetId ());

  m_state = DISABLED;

  // invoke energy depletion callback, if set.

  if (!m_energyDepletionCallback.IsNull ())

    {

      m_energyDepletionCallback ();

    }

}

void

ResonantChargerEnergyModel::HandleEnergyRecharged (void)

{

  NS_LOG_FUNCTION (this);

  NS_LOG_DEBUG ("ResonantChargerEnergyModel:Energy is recharged at node #" <<

                m_node->GetId ());

  m_state = OFF;

  // invoke energy recharge callback, if set.

  if (!m_energyRechargeCallback.IsNull ())

    {

      m_energyRechargeCallback ();

    }

}

/*

 * Private functions start here.

 */

void

ResonantChargerEnergyModel::DoDispose (void)

{

  NS_LOG_FUNCTION (this);

}

double

ResonantChargerEnergyModel::DoGetCurrentA (void) const

{

  NS_LOG_FUNCTION (this);

  return m_actualCurrentDrain;

}

double

ResonantChargerEnergyModel::GetChargingPowerRate ()

{

  NS_LOG_FUNCTION (this);

  return m_resonatorPowerRate;

}

void

ResonantChargerEnergyModel::SetChargingPowerRate (double power)

{

  NS_LOG_FUNCTION (this);

  m_resonatorPowerRate = power;

}

void

ResonantChargerEnergyModel::AddRechargableNodes (const NodeContainer nodeContainer)

{

  m_nodeContainer.Add (nodeContainer);

}

void

ResonantChargerEnergyModel::AddRechargableNode (const Ptr<Node> node)

{

  NS_ASSERT (node != NULL);

  m_nodeContainer.Add (node);

}

double

ResonantChargerEnergyModel::CalculateDistance (const Ptr<Node> node)

{

  NS_ASSERT (GetNode ()->GetObject<MobilityModel> () != NULL);

  NS_ASSERT (node->GetObject<MobilityModel> () != NULL);

  double distance = GetNode ()->GetObject<MobilityModel> ()

    ->GetDistanceFrom (node->GetObject<MobilityModel> ());

  return distance;

}

void

ResonantChargerEnergyModel::Charge ()

{

  NodeContainer::Iterator i = m_nodeContainer.Begin ();

  while (i != m_nodeContainer.End ())

    {

      DoCharge (*i);

      i++;

    }

  Simulator::Schedule (Seconds (1), &ResonantChargerEnergyModel::Charge, this);

}

void

ResonantChargerEnergyModel::DoCharge (const Ptr<Node> node)

{

  double power = m_resonatorPowerRate - (CalculateDistance (node) * m_powerLossPerDistance);

  if (power < 0 || m_state == OFF || m_state == DISABLED)

    {

      power = 0;

    }

  Ptr<ResonantEnergyHarvester> resonantHarvester = node->GetObject<EnergyHarvesterContainer> ()->Get (0)

    ->GetObject<ResonantEnergyHarvester> ();

  if(resonantHarvester != NULL)

    {

      resonantHarvester->SetHarvestablePower (power);

    }

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#ifndef RESONANT_CHARGER_ENERGY_MODEL_H

#define RESONANT_CHARGER_ENERGY_MODEL_H

#include "ns3/device-energy-model.h"

#include "ns3/energy-source.h"

#include "ns3/event-id.h"

#include "ns3/traced-value.h"

#include "ns3/log.h"

#include "ns3/simulator.h"

#include "ns3/node-container.h"

namespace ns3 {

/**

 * \ingroup energy

 * \brief Keeps track of the SAUV energy consumption

 *

 * The class model the energy consumed by the Resonant Charger.

 *

 * 

 */

class ResonantChargerEnergyModel : public DeviceEnergyModel

{

public:

  // / Callback type for energy depletion handling.

  typedef Callback<void> ResonantChargerEnergyDepletionCallback;

  // / Callback type for energy recharge handling.

  typedef Callback<void> ResonantChargerEnergyRechargeCallback;

  enum State

  {

    OFF,      //!< OFF.

    ON,       //!< ON.

    DISABLED  //!< Disabled.

  };

public:

  static TypeId GetTypeId (void);

  ResonantChargerEnergyModel ();

  virtual ~ResonantChargerEnergyModel ();

  /**

   * \brief Sets pointer to node.

   *

   * \param node Pointer to node.

   *

   * Implements DeviceEnergyModel::SetNode.

   */

  virtual void SetNode (Ptr<Node> node);

  /**

   * \brief Gets pointer to node.

   *

   * \returns Pointer to node.

   *

   * Implements DeviceEnergyModel::GetNode.

   */

  virtual Ptr<Node> GetNode (void) const;

  /**

   * \brief Sets pointer to EnergySouce installed on node.

   *

   * \param source Pointer to EnergySource installed on node.

   *

   * Implements DeviceEnergyModel::SetEnergySource.

   */

  virtual void SetEnergySource (Ptr<EnergySource> source);

  /**

   * \returns Total energy consumption of the vehicle.

   *

   * Implements DeviceEnergyModel::GetTotalEnergyConsumption.

   */

  virtual double GetTotalEnergyConsumption (void) const;

  /**

   * \param newState New state the device is in.

   *

   * DeviceEnergyModel is a state based model. This function is implemented by

   * all child of DeviceEnergyModel to change the model's state. States are to

   * be defined by each child using an enum (int).

   */

  virtual void ChangeState (int newState);

  /**

   *

   * Update the energy consumption.

   */

  void ChangeEnergyConsumption ();

  /**

   * \param callback Callback function.

   *

   * Sets callback for energy depletion handling.

   */

  void SetEnergyDepletionCallback (ResonantChargerEnergyDepletionCallback callback);

  /**

   * \param callback Callback function.

   *

   * Sets callback for energy recharge handling.

   */

  void SetEnergyRechargeCallback (ResonantChargerEnergyRechargeCallback callback);

  /**

   * \brief Handles energy depletion.

   *

   * Implements DeviceEnergyModel::HandleEnergyDepletion

   */

  virtual void HandleEnergyDepletion (void);

  /**

   * \brief Handles energy recharge.

   *

   * Implements DeviceEnergyModel::HandleEnergyRecharged

   */

  virtual void HandleEnergyRecharged (void);

  /**

   * \param the power rate of the charger.

   *

   * Sets the charging rate of the charger.

   */

  void SetChargingPowerRate (double power);

  /**

   * \returns the power rate of the charger.

   *

   * Gets the charging rate of the charger.

   */

  double GetChargingPowerRate ();

  /**

   * \param the status of the charger.

   *

   * Sets the status of the charger.

   */

  void SetState (State state);

  /**

   * \returns the status charger.

   *

   * Gets the status of the charger.

   */

  State GetState ();

  /**

   * \param the nodes to be charged.

   *

   * Adds the nodes to be charged.

   */

  void AddRechargableNodes (const NodeContainer nodeContainer);

  /**

  * \param a node to be charged.

  *

  * Adds a node to be charged.

  */

  void AddRechargableNode (const Ptr<Node> node);

private:

  void DoDispose (void);

  /**

   * \returns Current draw of device, at current state.

   *

   * Implements DeviceEnergyModel::GetCurrentA.

   */

  virtual double DoGetCurrentA (void) const;

  /**

   * \returns the distance to the node.

   * \param the node

   *

   * Calculate the distance to the node

   */

  double CalculateDistance (const Ptr<Node> node);

  /**

  * \param the node to be recharged

  *

  * charge the the node

  */

  void DoCharge (const Ptr<Node> node);

  /**

   * Charge all the nodes

   */

  void Charge ();

private:

  Ptr<Node> m_node;

  Ptr<EnergySource> m_source;

  // This variable keeps track of the total energy consumed by this particular model.

  TracedValue<double> m_totalEnergyConsumption;

  // actual current drain

  double m_actualCurrentDrain;

  // time stamp of previous energy update

  Time m_lastUpdateTime;

  // power rate of the resonator

  double m_resonatorPowerRate;

  // The power loss per unit distance

  double m_powerLossPerDistance;

  // the status of the resonator

  State m_state;

  // energy depletion callback

  ResonantChargerEnergyDepletionCallback m_energyDepletionCallback;

  // energy recharge callback

  ResonantChargerEnergyRechargeCallback m_energyRechargeCallback;

  // The nodes to be recharged

  NodeContainer m_nodeContainer;

};

} // namespace ns3

#endif /* RESONANT_CHARGER_ENERGY_MODEL_H */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#include "resonant-energy-harvester.h"

#include "ns3/log.h"

#include "ns3/simulator.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("ResonantEnergyHarvester");

NS_OBJECT_ENSURE_REGISTERED (ResonantEnergyHarvester);

TypeId

ResonantEnergyHarvester::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::ResonantEnergyHarvester")

    .SetParent<EnergyHarvester> ()

    .SetGroupName ("AUV")

    .AddConstructor<ResonantEnergyHarvester> ()

    .AddAttribute ("PeriodicHarvestedPowerUpdateInterval",

                   "Time between two consecutive periodic updates of the harvested power. By default, the value is updated every 1 s",

                   TimeValue (Seconds (1.0)),

                   MakeTimeAccessor (&ResonantEnergyHarvester::SetHarvestedPowerUpdateInterval,

                                     &ResonantEnergyHarvester::GetHarvestedPowerUpdateInterval),

                   MakeTimeChecker ())

    .AddTraceSource ("HarvestedPower",

                     "Harvested power by the ResonantEnergyHarvester.",

                     MakeTraceSourceAccessor (&ResonantEnergyHarvester::m_harvestedPower),

                     "ns3::TracedValueCallback::Double")

    .AddTraceSource ("TotalEnergyHarvested",

                     "Total energy harvested by the harvester.",

                     MakeTraceSourceAccessor (&ResonantEnergyHarvester::m_totalEnergyHarvestedJ),

                     "ns3::TracedValueCallback::Double")

  ;

  return tid;

}

ResonantEnergyHarvester::ResonantEnergyHarvester ()

  : m_harvestablePower (0)

{

  NS_LOG_FUNCTION (this);

}

ResonantEnergyHarvester::ResonantEnergyHarvester (Time updateInterval)

  : m_harvestablePower (0)

{

  NS_LOG_FUNCTION (this << updateInterval);

  m_harvestedPowerUpdateInterval = updateInterval;

}

ResonantEnergyHarvester::~ResonantEnergyHarvester ()

{

  NS_LOG_FUNCTION (this);

}

void

ResonantEnergyHarvester::SetHarvestedPowerUpdateInterval (Time updateInterval)

{

  NS_LOG_FUNCTION (this << updateInterval);

  m_harvestedPowerUpdateInterval = updateInterval;

}

Time

ResonantEnergyHarvester::GetHarvestedPowerUpdateInterval (void) const

{

  NS_LOG_FUNCTION (this << m_harvestedPowerUpdateInterval);

  return m_harvestedPowerUpdateInterval;

}

void

ResonantEnergyHarvester::SetHarvestablePower (double power)

{

  NS_LOG_FUNCTION (this);

  m_harvestablePower = power;

}

/*

 * Private functions start here.

 */

void

ResonantEnergyHarvester::UpdateHarvestedPower (void)

{

  NS_LOG_FUNCTION (this);

  NS_LOG_DEBUG (Simulator::Now ().GetSeconds ()

                << "s ResonantEnergyHarvester(" << GetNode ()->GetId () << "): Updating harvesting power.");

  Time duration = Simulator::Now () - m_lastHarvestingUpdateTime;

  NS_ASSERT (duration.GetNanoSeconds () >= 0); // check if duration is valid

  double energyHarvested = 0.0;

  // do not update if simulation has finished

  if (Simulator::IsFinished ())

    {

      NS_LOG_DEBUG ("ResonantEnergyHarvester: Simulation Finished.");

      return;

    }

  m_energyHarvestingUpdateEvent.Cancel ();

  if(GetEnergySource ()->GetEnergyFraction () >= 1)

    {

      m_harvestedPower = 0;

    }

  else

    {

      m_harvestedPower = m_harvestablePower;

    }

  energyHarvested = duration.GetSeconds () * m_harvestedPower;

  // update total energy harvested

  m_totalEnergyHarvestedJ += energyHarvested;

  // notify energy source

  GetEnergySource ()->UpdateEnergySource ();

  // update last harvesting time stamp

  m_lastHarvestingUpdateTime = Simulator::Now ();

  m_energyHarvestingUpdateEvent = Simulator::Schedule (m_harvestedPowerUpdateInterval,

                                                       &ResonantEnergyHarvester::UpdateHarvestedPower,

                                                       this);

}

void

ResonantEnergyHarvester::DoInitialize (void)

{

  NS_LOG_FUNCTION (this);

  m_lastHarvestingUpdateTime = Simulator::Now ();

  UpdateHarvestedPower ();  // start periodic harvesting update

}

void

ResonantEnergyHarvester::DoDispose (void)

{

  NS_LOG_FUNCTION (this);

}

double

ResonantEnergyHarvester::DoGetPower (void) const

{

  NS_LOG_FUNCTION (this);

  return m_harvestedPower;

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#ifndef RESONANT_ENERGY_HARVESTER

#define RESONANT_ENERGY_HARVESTER

#include "ns3/traced-value.h"

#include "ns3/nstime.h"

#include "ns3/event-id.h"

#include "ns3/energy-harvester.h"

namespace ns3 {

/**

 * \ingroup energy

 * ResonantEnergyHarvester increases remaining energy stored in an associated

 * Energy Source. The ResonantEnergyHarvester implements a simple model in which

 * the amount of power provided by the harvester is constant over time according

 *

 * Unit of power is chosen as Watt since energy models typically calculate

 * energy as (time in seconds * power in Watt).

 *

 */

class ResonantEnergyHarvester: public EnergyHarvester

{

public:

  static TypeId GetTypeId (void);

  ResonantEnergyHarvester ();

  /**

   * \param updateInterval Energy harvesting update interval.

   *

   * ResonantEnergyHarvester constructor function that sets the interval

   * between each update of the value of the power harvested by this

   * energy harvester.

   */

  ResonantEnergyHarvester (Time updateInterval);

  virtual ~ResonantEnergyHarvester ();

  /**

   * \param updateInterval Energy harvesting update interval.

   *

   * This function sets the interval between each update of the value of the

   * power harvested by this energy harvester.

   */

  void SetHarvestedPowerUpdateInterval (Time updateInterval);

  /**

   * \returns The interval between each update of the harvested power.

   *

   * This function returns the interval between each update of the value of the

   * power harvested by this energy harvester.

   */

  Time GetHarvestedPowerUpdateInterval (void) const;

  void SetHarvestablePower (double power);

private:

  /// Defined in ns3::Object

  void DoInitialize (void);

  /// Defined in ns3::Object

  void DoDispose (void);

  /**

   * \returns m_harvestedPower The power currently provided by the Resonant Energy Harvester.

   * Implements DoGetPower defined in EnergyHarvester.

   */

  virtual double DoGetPower (void) const;

  /**

   * This function is called every m_energyHarvestingUpdateInterval in order to

   * update the amount of power that will be provided by the harvester in the

   * next interval.

   */

  void UpdateHarvestedPower (void);

private:

  double m_harvestablePower;                    // harvestable power in Watt

  TracedValue<double> m_harvestedPower;         // current harvested power, in Watt

  TracedValue<double> m_totalEnergyHarvestedJ;  // total harvested energy, in Joule

  EventId m_energyHarvestingUpdateEvent;        // energy harvesting event

  Time m_lastHarvestingUpdateTime;              // last harvesting time

  Time m_harvestedPowerUpdateInterval;          // harvestable energy update interval

};

} // namespace ns3

#endif /* defined(RESONANT_ENERGY_HARVESTER) */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#include "solar-energy-harvester.h"

#include "ns3/mobility-model.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("SolarEnergyHarvester");

NS_OBJECT_ENSURE_REGISTERED (SolarEnergyHarvester);

TypeId

SolarEnergyHarvester::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::SolarEnergyHarvester")

    .SetParent<EnergyHarvester> ()

    .SetGroupName ("AUV")

    .AddConstructor<SolarEnergyHarvester> ()

    .AddAttribute ("PeriodicHarvestedPowerUpdateInterval",

                   "Time between two consecutive periodic updates of the harvested power. By default, the value is updated every 1 s",

                   TimeValue (Seconds (1.0)),

                   MakeTimeAccessor (&SolarEnergyHarvester::SetHarvestedPowerUpdateInterval,

                                     &SolarEnergyHarvester::GetHarvestedPowerUpdateInterval),

                   MakeTimeChecker ())

    .AddAttribute ("HarvestablePower",

                   "The harvestable power [Watts] that the solar energy harvester is allowed to harvest.",

                   DoubleValue (85),

                   MakeDoubleAccessor (&SolarEnergyHarvester::m_harvestablePower),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("SunriseHour",

                   "The sunrise Hour in 24 hours format.",

                   IntegerValue (7),

                   MakeIntegerAccessor (&SolarEnergyHarvester::m_sunriseHour),

                   MakeIntegerChecker<int> ())

    .AddAttribute ("SunsetHour",

                   "The sunset Hour in 24 hours format.",

                   IntegerValue (17),

                   MakeIntegerAccessor (&SolarEnergyHarvester::m_sunsetHour),

                   MakeIntegerChecker<int> ())

    .AddAttribute ("UnderwaterMode",

                   "Disable energy harvesting when depth < 0.",

                   BooleanValue (false),

                   MakeBooleanAccessor (&SolarEnergyHarvester::m_underwaterMode),

                   MakeBooleanChecker ())

    .AddTraceSource ("HarvestedPower",

                     "Harvested power by the SolarEnergyHarvester.",

                     MakeTraceSourceAccessor (&SolarEnergyHarvester::m_harvestedPower),

                     "ns3::TracedValueCallback::Double")

    .AddTraceSource ("TotalEnergyHarvested",

                     "Total energy harvested by the harvester.",

                     MakeTraceSourceAccessor (&SolarEnergyHarvester::m_totalEnergyHarvestedJ),

                     "ns3::TracedValueCallback::Double")

  ;

  return tid;

}

SolarEnergyHarvester::SolarEnergyHarvester ()

{

  NS_LOG_FUNCTION (this);

}

SolarEnergyHarvester::SolarEnergyHarvester (Time updateInterval)

{

  NS_LOG_FUNCTION (this << updateInterval);

  m_harvestedPowerUpdateInterval = updateInterval;

}

SolarEnergyHarvester::~SolarEnergyHarvester ()

{

  NS_LOG_FUNCTION (this);

}

void

SolarEnergyHarvester::SetHarvestedPowerUpdateInterval (Time updateInterval)

{

  NS_LOG_FUNCTION (this << updateInterval);

  m_harvestedPowerUpdateInterval = updateInterval;

}

Time

SolarEnergyHarvester::GetHarvestedPowerUpdateInterval (void) const

{

  NS_LOG_FUNCTION (this);

  return m_harvestedPowerUpdateInterval;

}

void

SolarEnergyHarvester::SetHarvestablePower (double power)

{

  m_harvestablePower = power;

}

/*

 * Private functions start here.

 */

void

SolarEnergyHarvester::UpdateHarvestedPower (void)

{

  NS_LOG_FUNCTION (this);

  NS_LOG_DEBUG (Simulator::Now ().GetSeconds ()

                << "s SolarEnergyHarvester(" << GetNode ()->GetId () << "): Updating harvesting power.");

  Time duration = Simulator::Now () - m_lastHarvestingUpdateTime;

  NS_ASSERT (duration.GetNanoSeconds () >= 0); // check if duration is valid

  double energyHarvested = 0.0;

  // do not update if simulation has finished

  if (Simulator::IsFinished ())

    {

      NS_LOG_DEBUG ("SolarEnergyHarvester: Simulation Finished.");

      return;

    }

  Ptr<MobilityModel> mob = GetNode ()->GetObject<MobilityModel>();

  NS_ASSERT (mob != NULL);

  Vector position = mob->GetPosition ();

  double depth = position.z;

  m_energyHarvestingUpdateEvent.Cancel ();

  if(!m_sunlight || (m_underwaterMode && depth < 0) || GetEnergySource ()->GetEnergyFraction () >= 1)

    {

      m_harvestedPower = 0;

    }

  else

    {

      m_harvestedPower = m_harvestablePower;

    }

  energyHarvested = duration.GetSeconds () * m_harvestedPower;

  // update total energy harvested

  m_totalEnergyHarvestedJ += energyHarvested;

  // notify energy source

  GetEnergySource ()->UpdateEnergySource ();

  // update last harvesting time stamp

  m_lastHarvestingUpdateTime = Simulator::Now ();

  m_energyHarvestingUpdateEvent = Simulator::Schedule (m_harvestedPowerUpdateInterval,

                                                       &SolarEnergyHarvester::UpdateHarvestedPower,

                                                       this);

}

void

SolarEnergyHarvester::DoInitialize (void)

{

  NS_LOG_FUNCTION (this);

  m_lastHarvestingUpdateTime = Simulator::Now ();

  SwitchDayNight ();

  UpdateHarvestedPower ();  // start periodic harvesting update

}

void

SolarEnergyHarvester::DoDispose (void)

{

  NS_LOG_FUNCTION (this);

}

double

SolarEnergyHarvester::DoGetPower (void) const

{

  NS_LOG_FUNCTION (this);

  return m_harvestedPower;

}

void

SolarEnergyHarvester::SetSolarHavestingHours (int sunriseHour, int sunsetHour)

{

  m_sunriseHour = sunriseHour;

  m_sunsetHour = sunsetHour;

}

void

SolarEnergyHarvester::SwitchDayNight (void)

{

  int hours = Simulator::Now ().GetHours ();

  hours %= 24;

  if(hours >= m_sunriseHour && hours <= m_sunsetHour)

    {

      m_sunlight = true;

    }

  else

    {

      m_sunlight = false;

    }

  Simulator::Schedule (Hours (1), &SolarEnergyHarvester::SwitchDayNight, this );

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Hossam Khader <hossamkhader@gmail.com>

 */

#ifndef SOLAR_ENERGY_HARVESTER

#define SOLAR_ENERGY_HARVESTER

#include "ns3/traced-value.h"

#include "ns3/event-id.h"

#include "ns3/energy-harvester.h"

#include "ns3/log.h"

#include "ns3/simulator.h"

namespace ns3 {

/**

 * \ingroup energy

 * SolarEnergyHarvester increases remaining energy stored in an associated

 * Energy Source. The SolarEnergyHarvester implements a simple model in which

 * the amount of power provided by the harvester is constant over time according

 *

 * Unit of power is chosen as Watt since energy models typically calculate

 * energy as (time in seconds * power in Watt).

 *

 */

class SolarEnergyHarvester: public EnergyHarvester

{

public:

  static TypeId GetTypeId (void);

  SolarEnergyHarvester ();

  /**

   * \param updateInterval Energy harvesting update interval.

   *

   * ResonantEnergyHarvester constructor function that sets the interval

   * between each update of the value of the power harvested by this

   * energy harvester.

   */

  SolarEnergyHarvester (Time updateInterval);

  virtual ~SolarEnergyHarvester ();

  /**

   * \param updateInterval Energy harvesting update interval.

   *

   * This function sets the interval between each update of the value of the

   * power harvested by this energy harvester.

   */

  void SetHarvestedPowerUpdateInterval (Time updateInterval);

  /**

   * \returns The interval between each update of the harvested power.

   *

   * This function returns the interval between each update of the value of the

   * power harvested by this energy harvester.

   */

  Time GetHarvestedPowerUpdateInterval (void) const;

  /**

   * \param sunriseHour The sunriseHour in 24 hours format.

   * \param sunsetHour The sunsetHour in 24 hours format.

   *

   * This function sets the sunriseHour and sunsetHour

   * Solar energy can be harvested between these hours.

   */

  void SetSolarHavestingHours (int sunriseHour, int sunsetHour);

  /**

   * \param power The maximum harvestable solar power

   *

   * This function sets the maximum solar power that can be harvested

   */

  void SetHarvestablePower (double power);

private:

  /// Defined in ns3::Object

  void DoInitialize (void);

  /// Defined in ns3::Object

  void DoDispose (void);

  /**

   * This function simulates the availability of the sunlight during

   * the day

   */

  void SwitchDayNight (void);

  /**

   * \returns m_harvestedPower The power currently provided by the Resonant Energy Harvester.

   * Implements DoGetPower defined in EnergyHarvester.

   */

  virtual double DoGetPower (void) const;

  /**

   * This function is called every m_energyHarvestingUpdateInterval in order to

   * update the amount of power that will be provided by the harvester in the

   * next interval.

   */

  void UpdateHarvestedPower (void);

private:

  double m_harvestablePower;                    // harvestable power in Watt

  TracedValue<double> m_harvestedPower;         // current harvested power, in Watt

  TracedValue<double> m_totalEnergyHarvestedJ;  // total harvested energy, in Joule

  EventId m_energyHarvestingUpdateEvent;        // energy harvesting event

  Time m_lastHarvestingUpdateTime;              // last harvesting time

  Time m_harvestedPowerUpdateInterval;          // harvestable energy update interval

  bool m_sunlight;                              // availability of the sunlight

  int m_sunriseHour;                            // sunrise hour in 24 hours format

  int m_sunsetHour;                             // sunset hour in 24 hours format

  bool m_underwaterMode;                        // underwater mode

};

} // namespace ns3

#endif /* defined(SOLAR_ENERGY_HARVESTER) */

		'model/resonant-charger-energy-model.cc',

		'model/resonant-energy-harvester.cc',

		'model/solar-energy-harvester.cc',

		'helper/resonant-charger-helper.cc',

		'helper/resonant-energy-harvester-helper.cc',

		'helper/solar-energy-harvester-helper.cc',

		'model/resonant-charger-energy-model.h',

		'model/resonant-energy-harvester.h',

		'model/solar-energy-harvester.h',

		'helper/resonant-charger-helper.h',

		'helper/resonant-energy-harvester-helper.h',

		'helper/solar-energy-harvester-helper.h',