source: PSPA/Interface_Web/trunk/pspaWT/include/bareParticle.h @ 83

#ifndef BAREPARTICLE_SEEN
#define BAREPARTICLE_SEEN

#include <iostream>
#include <sstream>

#include <cmath>


#include "mathematicalTools.h"

using namespace std;

class bareParticle 
{

 protected:

  TRIDVECTOR position_;
  TRIDVECTOR betagamma_;
  double gamma_;



 protected:




 public :

  bareParticle() {;}

~bareParticle() {;}

 inline bareParticle& operator = (const bareParticle& bp)
   {
     position_ = bp.position_;
     betagamma_ = bp.betagamma_;
     gamma_ = bp.gamma_;
     return *this;
   }

 bareParticle(const TRIDVECTOR&  pos , const TRIDVECTOR& bg)
   {
     position_ = pos;
     betagamma_ = bg;
     gamma_ = sqrt( 1.0 + betagamma_.norm2() );
   }

 inline void resetDynamics(const bareParticle& bp)
  {
    position_ = bp.position_;
    betagamma_ = bp.betagamma_;
    gamma_ = bp.gamma_;

  }



inline  const TRIDVECTOR& getReferenceToPosition() const
  {
    return position_;
  }

inline  TRIDVECTOR getPosition() const
  {
    return position_;
  }

 inline  TRIDVECTOR& getReferenceToPosition() 
  {
    return position_;
  }

inline  double getZ() const
  {
    return position_.getComponent(2);
  }


inline void setZ(double z) 
  {
    position_.setComponent(2, z);
  }

 inline  void incrementZ( double dz) 
  {
    position_.incrementComponent(2, dz);
  }

inline   void setX(double x) 
  {
    position_.setComponent(0, x);
  }


inline   double getRadius() const
  {
    double auxx = position_.getComponent(0);
    double auxy = position_.getComponent(1);

    return sqrt(auxx * auxx + auxy * auxy);
  }


inline  TRIDVECTOR getBetaGamma() const
  {
    return betagamma_;
  }


inline TRIDVECTOR& getReferenceToBetaGamma() 
  {
    return betagamma_;
  }
 
inline void setBetaGamma(const TRIDVECTOR& btg) 
  {
    betagamma_ = btg;
     gamma_ = sqrt( 1.0 + betagamma_.norm2() );
  }

inline double getBetaz() const
  {
    return betagamma_.getComponent(2)/gamma_;
  }


inline  double getGamma() const 
  {
    return gamma_;
  }


 void imprimer() const; 


 inline string FileOutputFlow() const
  {
    ostringstream sortie;
    sortie << position_.output_flow()  << betagamma_.output_flow() << " " <<  gamma_;
    return sortie.str();
  }

virtual inline bool FileInput( ifstream& ifs)
 {
    bool test = false;
    if ( position_.input_flow(ifs) && betagamma_.input_flow(ifs) )
      { 
        if (  ifs >> gamma_ ) 
          {
            test = true;
          }
      } 
    return test;
 }


};




#endif