Vector.h

////////////////////////////////////////////////////////////////////////////////////////////////
//class Vector:
//This class represents a three-vector.  Operators are overloaded to provide for the
//familiar operations of vector addition, subtraction, scalar multiplication and division,
//and the dot product.  The x,y,z components can be output with the << operator onto an
//output stream.
//Methods are provided to take the vector product, find the magnitude, find a three-dimensional
//angle, and perform various rotations.
//
//The only methods that will alter an established vector are Reset and the three Set functions.
//All other methods (cross product, rotations, etc.) return a new Vector object.
////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef VECTOR_H
#define VECTOR_H

#include "TObject.h"
#include <iostream>

class Vector {
//class Vector : public TObject {

protected:
  //Class variables
  double x; //x component of vector
  double y; //y component of vector
  double z; //z component of vector
  double theta;  //theta component of vector in radians
  double phi; //phi component of vector in radians

  double r; //r component of vector

  //Class private functions
  void UpdateThetaPhi(); 
  void UpdateXYZ(); 
  //This method finds theta and phi from the x,y,z Cartesian coordinates.  
  //It should be called at any time that the x,y,z components are modified,
  //so that the theta and phi components are current at all times.





public:
  friend Vector operator +(const Vector& vector1, const Vector& vector2);
  //Add two vectors component by component

  friend void operator +=(Vector& vector1, const Vector& vector2);

  friend Vector operator -(const Vector& vector1, const Vector& vector2);
  //Subtract two vectors component by component

  friend void operator -=(Vector& vector1, const Vector& vector2);

  friend Vector operator -(const Vector& vec);
  //Gives the negative of a vector

  friend double operator *(const Vector& vector1, const Vector& vector2);
  //Take the dot product of two vectors

  friend Vector operator /(const Vector &v, const double& a);
  //Divide a vector by a scalar

  friend Vector operator *(const double& a, const Vector& v);
  //Multiply a vector by a scalar

  friend std::ostream& operator <<(std::ostream& outs, const Vector& vec);
  //Print the three rectangular components of the vector to the screen

  double operator [](int i) const;
  //Returns an element of the vector.  vector[0] is the x component,
  //vector[1] is the y component, and vector[2] is the z component.

  Vector(double x_inp,double y_inp,double z_inp);
  //Constructor: Initialize a new vector with given values of x, y, and z.

  Vector(double *xarray);
  //Constructor: Initialize a new vector with elements of xarray giving values 
  // of x,y,z.

  Vector(double theta, double phi);
  //Constructor: Initialize a new vector with unit length and in the
  //theta, phi direction.
  //theta and phi must be in RADIANS!
  //Accepts theta from 0 to PI, and any phi.
  
  Vector();
  //Default constructor: Initialize a unit vector in the z direction.

  Vector RotateX(double angle) const;
  //Returns the vector rotated counterclockwise (right handed coordinates) 
  //by "angle" radians about the X axis.
  //N.B. : Returns a new Vector object.  Does not change the vector it is called from.

  Vector RotateY(double angle) const;
  //Returns the vector rotated counterclockwise (right handed coordinates) 
  //by "angle" radians about the Y axis.
  //N.B. : Returns a new Vector object.  Does not change the vector it is called from.

  Vector RotateZ(double angle) const;
  //Returns the vector rotated counterclockwise (right handed coordinates) 
  //by "angle" radians about the Z axis.
  //N.B. : Returns a new Vector object.  Does not change the vector it is called from.

  Vector Cross(const Vector &vec) const;
  //Takes the cross product  this x vec.

  double Dot(const Vector &vec) const;
//Takes the dot product  this x vec.

  Vector Rotate(double angle, const Vector &axis) const;
  //Returns the vector that is this vector rotated around the vector "axis" by angle (in radians) "angle".

  Vector Zero();
  //zero the vector

  double Mag() const;
  //Returns the magnitude of this vector.

  double Angle(const Vector &vec) const;
  //Returns the 3-dimensional angle between this vector and the argument.

  Vector ChangeCoord(const Vector &new_x_axis,const Vector &new_y_axis) const;
  Vector ChangeCoord(const Vector &new_z_axis) const;
  //Returns this vector, rotated to a new coordinate system with the argument as the z-axis.
  //The vector is rotated in such a way that a vector pointing in the z direction will be 
  //rotated onto the new axis.

  Vector Unit() const;
  //Returns a unit vector in the same direction as this vector.

  //Accessor functions
  double GetX() const;
  double GetY() const;
  double GetZ() const;
  double R() const;
  double Theta() const;
  double Phi() const;
  void Print() const;
  void PrintSp() const;

  //Mutator functions
  void SetX(double inp);
  void SetY(double inp);
  void SetZ(double inp);
  void SetXYZ(double inpx,double inpy,double inpz);
  
  void SetR(double inpr);
  void SetThetaPhi(double inptheta,double inpphi);
  void SetRThetaPhi(double inpr,double inptheta,double inpphi);

  void Reset(double x_inp, double y_inp, double z_inp);

  ClassDef(Vector,1);

}; //class Vector

////////////////////////////////////////////////////////////////////////////////////////////////

#endif //VECTOR_H