powerpack.cc

Go to the documentation of this file.

#include "stage.hh"
#include "texture_manager.hh"
using namespace Stg;

joules_t PowerPack::global_stored = 0.0;
joules_t PowerPack::global_input = 0.0;
joules_t PowerPack::global_capacity = 0.0;
joules_t PowerPack::global_dissipated = 0.0;

PowerPack::PowerPack(Model *mod)
    : event_vis(2.0 * std::max(fabs(ceil(mod->GetWorld()->GetExtent().x.max)),
                               fabs(floor(mod->GetWorld()->GetExtent().x.min))),
                2.0 * std::max(fabs(ceil(mod->GetWorld()->GetExtent().y.max)),
                               fabs(floor(mod->GetWorld()->GetExtent().y.min))),
                1.0),
      output_vis(0, 100, 200, 40, 1200, Color(1, 0, 0), Color(0, 0, 0, 0.5), "energy output",
                 "energy_input"),
      stored_vis(0, 142, 200, 40, 1200, Color(0, 1, 0), Color(0, 0, 0, 0.5), "energy stored",
                 "energy_stored"),
      mod(mod), stored(0.0), capacity(0.0), charging(false), dissipated(0.0), last_time(0),
      last_joules(0.0), last_watts(0.0)
{
  // tell the world about this new pp
  mod->world->AddPowerPack(this);

  mod->AddVisualizer(&event_vis, false);
  mod->AddVisualizer(&output_vis, false);
  mod->AddVisualizer(&stored_vis, false);
}

PowerPack::~PowerPack()
{
  mod->world->RemovePowerPack(this);
  mod->RemoveVisualizer(&event_vis);
  mod->RemoveVisualizer(&output_vis);
  mod->RemoveVisualizer(&stored_vis);
}

void PowerPack::Visualize(Camera *cam)
{
  (void)cam; // avoid warning about unused var

  const double height = 0.5;
  const double width = 0.2;

  double percent = stored / capacity * 100.0;

  const double alpha = 0.5;

  if (percent > 50)
    glColor4f(0, 1, 0, alpha); // green
  else if (percent > 25)
    glColor4f(1, 0, 1, alpha); // magenta
  else
    glColor4f(1, 0, 0, alpha); // red

  //  snprintf( buf, 32, "%.0f", percent );

  glTranslatef(-width, 0.0, 0.0);

  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

  GLfloat fullness = height * (percent * 0.01);
  glRectf(0, 0, width, fullness);

  // outline the charge-o-meter
  glTranslatef(0, 0, 0.1);
  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

  glColor4f(0, 0, 0, 0.7);

  glRectf(0, 0, width, height);

  glBegin(GL_LINES);
  glVertex2f(0, fullness);
  glVertex2f(width, fullness);
  glEnd();

  if (stored < 0.0) // inifinite supply!
  {
    // draw an arrow toward the top
    glBegin(GL_LINES);
    glVertex2f(width / 3.0, height / 3.0);
    glVertex2f(2.0 * width / 3, height / 3.0);

    glVertex2f(width / 3.0, height / 3.0);
    glVertex2f(width / 3.0, height - height / 5.0);

    glVertex2f(width / 3.0, height - height / 5.0);
    glVertex2f(0, height - height / 5.0);

    glVertex2f(0, height - height / 5.0);
    glVertex2f(width / 2.0, height);

    glVertex2f(width / 2.0, height);
    glVertex2f(width, height - height / 5.0);

    glVertex2f(width, height - height / 5.0);
    glVertex2f(2.0 * width / 3.0, height - height / 5.0);

    glVertex2f(2.0 * width / 3.0, height - height / 5.0);
    glVertex2f(2.0 * width / 3, height / 3.0);

    glEnd();
  }

  if (charging) {
    glLineWidth(6.0);
    glColor4f(1, 0, 0, 0.7);

    glRectf(0, 0, width, height);

    glLineWidth(1.0);
  }

  // compute the instantaneous power output
  usec_t time_now = mod->world->SimTimeNow();
  usec_t delta_t = time_now - last_time;
  watts_t watts = last_watts;

  if (delta_t > 0) // some sim time elapsed
  {
    joules_t delta_j = stored - last_joules;
    watts_t watts = (-1e6 * delta_j) / (double)delta_t;

    last_joules = stored;
    last_time = time_now;
    last_watts = watts;
  }

  if (fabs(watts) > 1e-5) // any current
  {
    glColor4f(1, 0, 0, 0.8); // red
    char buf[32];
    snprintf(buf, 32, "%.1fW", watts);
    Gl::draw_string(-0.05, height + 0.05, 0, buf);
  }
}

joules_t PowerPack::RemainingCapacity() const
{
  return (capacity - stored);
}

void PowerPack::Add(joules_t j)
{
  joules_t amount = std::min(RemainingCapacity(), j);
  stored += amount;
  global_stored += amount;

  if (amount > 0)
    charging = true;
}

void PowerPack::Subtract(joules_t j)
{
  if (stored < 0) // infinte supply!
  {
    global_input += j; // record energy entering the system
    return;
  }

  joules_t amount = std::min(stored, j);

  stored -= amount;
  global_stored -= amount;
}

void PowerPack::TransferTo(PowerPack *dest, joules_t amount)
{
  // printf( "amount %.2f stored %.2f dest capacity %.2f\n",
  //     amount, stored, dest->RemainingCapacity() );

  // if stored is non-negative we can't transfer more than the stored
  // amount. If it is negative, we have infinite energy stored
  if (stored >= 0.0)
    amount = std::min(stored, amount);

  // we can't transfer more than he can take
  amount = std::min(amount, dest->RemainingCapacity());

  // printf( "%s gives %.3f J to %s\n",
  //     mod->Token(), amount, dest->mod->Token() );

  Subtract(amount);
  dest->Add(amount);

  mod->NeedRedraw();
}

void PowerPack::SetCapacity(joules_t cap)
{
  global_capacity -= capacity;
  capacity = cap;
  global_capacity += capacity;

  if (stored > cap) {
    global_stored -= stored;
    stored = cap;
    global_stored += stored;
  }
}

joules_t PowerPack::GetCapacity() const
{
  return capacity;
}

joules_t PowerPack::GetStored() const
{
  return stored;
}

joules_t PowerPack::GetDissipated() const
{
  return dissipated;
}

void PowerPack::SetStored(joules_t j)
{
  global_stored -= stored;
  stored = j;
  global_stored += stored;
}

void PowerPack::Dissipate(joules_t j)
{
  joules_t amount = (stored < 0) ? j : std::min(stored, j);

  Subtract(amount);
  dissipated += amount;
  global_dissipated += amount;

  output_vis.AppendValue(amount);
  stored_vis.AppendValue(stored);
}

void PowerPack::Dissipate(joules_t j, const Pose &p)
{
  Dissipate(j);
  event_vis.Accumulate(p.x, p.y, j);
}

//------------------------------------------------------------------------------
// Dissipation Visualizer class

joules_t PowerPack::DissipationVis::global_peak_value = 0.0;

PowerPack::DissipationVis::DissipationVis(meters_t width, meters_t height, meters_t cellsize)
    : Visualizer("energy dissipation", "energy_dissipation"), columns(width / cellsize),
      rows(height / cellsize), width(width), height(height), cells(columns * rows), peak_value(0),
      cellsize(cellsize)
{ /* nothing to do */
}

PowerPack::DissipationVis::~DissipationVis()
{
}

void PowerPack::DissipationVis::Visualize(Model *mod, Camera *cam)
{
  (void)cam; // avoid warning about unused var

  // go into world coordinates

  glPushMatrix();

  Gl::pose_inverse_shift(mod->GetGlobalPose());

  glTranslatef(-width / 2.0, -height / 2.0, 0.01);
  glScalef(cellsize, cellsize, 1);

  for (unsigned int y = 0; y < rows; y++)
    for (unsigned int x = 0; x < columns; x++) {
      joules_t j = cells[y * columns + x];

      // printf( "%d %d %.2f\n", x, y, j );

      if (j > 0) {
        glColor4f(1.0, 0, 0, j / global_peak_value);
        glRectf(x, y, x + 1, y + 1);
      }
    }

  glPopMatrix();
}

void PowerPack::DissipationVis::Accumulate(meters_t x, meters_t y, joules_t amount)
{
  // printf( "accumulate %.2f %.2f %.2f\n", x, y, amount );

  int ix = (x + width / 2.0) / cellsize;
  int iy = (y + height / 2.0) / cellsize;

  // don't accumulate if we're outside the grid
  if (ix < 0 || ix >= int(columns) || iy < 0 || iy >= int(rows))
    return;

  joules_t &j = cells[ix + (iy * columns)];

  j += amount;
  if (j > peak_value) {
    peak_value = j;

    if (peak_value > global_peak_value)
      global_peak_value = peak_value;
  }
}