GEnergy.h

/***************************************************************************
 *   Copyright (C) 2003-2004 by Raphael Langerhorst                        *
 *   raphael-langerhorst@gmx.at                                            *
 *                                                                         *
 *   Permission is hereby granted, free of charge, to any person obtaining *
 *   a copy of this software and associated documentation files (the       *
 *   "Software"), to deal in the Software without restriction, including   *
 *   without limitation the rights to use, copy, modify, merge, publish,   *
 *   distribute, sublicense, and/or sell copies of the Software, and to    *
 *   permit persons to whom the Software is furnished to do so, subject to *
 *   the following conditions:                                             *
 *                                                                         *
 *   The above copyright notice and this permission notice shall be        *
 *   included in all copies or substantial portions of the Software.       *
 *                                                                         *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       *
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    *
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR     *
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, *
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR *
 *   OTHER DEALINGS IN THE SOFTWARE.                                       *
 ***************************************************************************/


#ifndef GENERGYH
#define GENERGYH

#include <qmutex.h>

namespace GCS
{

class GEnergy : public QMutex
{
  protected:

    double Level;

    double Amount;

    double Sigma;


  public:
  
    GEnergy()
    : Level(0),
      Amount(0),
      Sigma(0)
    {}

    GEnergy(double level, double amount, double sigma)
    : Level(level),
      Amount(amount),
      Sigma(sigma)
    {}
    
    GEnergy(const GEnergy& original)
    : QMutex(),
      Level(original.Level),
      Amount(original.Amount),
      Sigma(original.Sigma)
    {}
      
    
    virtual ~GEnergy()
    {}
    
    double level() const {return Level;}
    
    double amount() const {return Amount;}
    
    double sigma() const {return Sigma;}
    
    void set(double level, double amount, double sigma)
    {
      this->Level = level;
      this->Amount = amount;
      this->Sigma = sigma;
    }
    
    void set(const GEnergy original)
    {
      set(original.Level,original.Amount,original.Sigma);
    }
    
    void operator = (const GEnergy& original)
    {
      set(original);
    }

    GEnergy take(double fraction)
    {
      if (fraction>1)
        fraction=1;
      double difference = Amount*fraction;
      Amount -=difference;
      return GEnergy(Level,difference,Sigma);
    }
    
    void put(GEnergy& energy)
    {
      if (energy.Amount<0)
        return;
        
      double fraction = energy.Amount / (this->Amount + energy.Amount);
      double d_Level = energy.Level - this->Level;
      double d_Sigma = energy.Sigma - this->Sigma;
      
      this->Amount += energy.Amount;
      this->Level += d_Level*fraction;
      
      //@todo: improve sigma addition
      double d_Level_abs = d_Level;
      if (d_Level_abs<0)
        d_Level_abs = -d_Level_abs;
      this->Sigma += (d_Sigma + d_Level_abs)*fraction;
      
      //now the energy is absorbed...
      energy.Level = this->Level;
      energy.Amount = 0;
      energy.Sigma = this->Sigma;
    }
};


}

#endif

---