vec Class Reference

#include <vec.h>

Inheritance diagram for vec:

Public Member Functions
vec	operator/ (vfloat p) const
	vec (vfloat xx, vfloat yy, vfloat zz)
	vec ()
virtual	~vec ()
vec	down_new (const basis *fabas)
void	down (const basis *fabas)
vec	up_new (const basis *fabas_new)
void	up (const basis *fabas_new)
vec	down_new (const abssyscoor *fasc)
void	down (const abssyscoor *fasc)
vec	up_new (const abssyscoor *fasc)
void	up (const abssyscoor *fasc)
vec	turn_new (const vec &dir, vfloat angle)
void	turn (const vec &dir, vfloat angle)
void	shift (const vec &dir)
void	random_round_vec (void)
void	random_conic_vec (double theta)
void	random_sfer_vec (void)
Public Member Functions inherited from absref
virtual	~absref ()
virtual void	down (const abssyscoor *fasc)
virtual void	up (const abssyscoor *fasc)
virtual void	turn (const vec &dir, vfloat angle)
virtual void	shift (const vec &dir)

Public Attributes
vfloat	x
vfloat	y
vfloat	z

Friends
vec	operator* (const vec &v, vfloat p)
vec	operator*= (vec &v, vfloat p)
vec	operator* (vfloat p, const vec &v)
vec	operator/= (vec &v, vfloat p)
vec	operator+ (const vec &r1, const vec &r2)
vec &	operator+= (vec &r1, const vec &r2)
vec	operator- (const vec &r1, const vec &r2)
vec	operator-= (vec &r1, const vec &r2)
vec	operator- (const vec &r)
vfloat	operator* (const vec &r1, const vec &r2)
vec	operator|| (const vec &r1, const vec &r2)
wl_inline int	operator== (const vec &r1, const vec &r2)
wl_inline int	operator!= (const vec &r1, const vec &r2)
wl_inline int	apeq (const vec &r1, const vec &r2, vfloat prec)
wl_inline int	not_apeq (const vec &r1, const vec &r2, vfloat prec)
vfloat	length (const vec &v)
vfloat	length2 (const vec &v)
wl_inline vec	unit_vec (const vec &v)
vfloat	cos2vec (const vec &r1, const vec &r2)
vfloat	ang2vec (const vec &r1, const vec &r2)
vec	project_to_plane (const vec &r, const vec &normal)
vfloat	ang2projvec (const vec &r1, const vec &r2, const vec &normal)
vfloat	sin2vec (const vec &r1, const vec &r2)
wl_inline int	check_par (const vec &r1, const vec &r2, vfloat prec)
wl_inline int	check_perp (const vec &r1, const vec &r2, vfloat prec)
wl_inline vec	switch_xyz (const vec &)

Detailed Description

Definition at line 248 of file vec.h.

Constructor & Destructor Documentation

vec() [1/2]

vec::vec ( vfloat  xx, vfloat  yy, vfloat  zz  )

inline

Definition at line 334 of file vec.h.

                                       {
    x = xx;
    y = yy;
    z = zz;
  }

vec() [2/2]

vec::vec ( )

inline

Definition at line 339 of file vec.h.

        {
    x = 0;
    y = 0;
    z = 0;
  }

Referenced by operator/(), and turn_new().

~vec()

virtual vec::~vec ( )

inlinevirtual

Definition at line 349 of file vec.h.

{}

Member Function Documentation

down() [1/2]

void vec::down ( const abssyscoor *  fasc )

virtual

Reimplemented from absref.

Definition at line 307 of file vec.cpp.

{ down(fasc->Gabas()); }

down() [2/2]

void vec::down

(

const basis *

fabas

)

Definition at line 247 of file vec.cpp.

{ *this = this->down_new(fabas); }

Referenced by down(), point::down(), Heed::ElElasticScat::fill_hist_low_scat(), Heed::HeedParticle::physics(), Heed::HeedParticle_BGM::physics(), and Heed::HeedDeltaElectron::physics_after_new_speed().

down_new() [1/2]

vec vec::down_new

(

const abssyscoor *

fasc

)

Definition at line 306 of file vec.cpp.

{ return down_new(fasc->Gabas()); }

down_new() [2/2]

vec vec::down_new

(

const basis *

fabas

)

Definition at line 232 of file vec.cpp.

                                    {
  //pvecerror("vec vec::down_new(void)");
  vec r;
  vec ex = fabas->Gex();
  vec ey = fabas->Gey();
  vec ez = fabas->Gez();
  r.x = x * ex.x + y * ey.x + z * ez.x;
  r.y = x * ex.y + y * ey.y + z * ez.y;
  r.z = x * ex.z + y * ey.z + z * ez.z;
  //mcout<<scout(*this);
  //mcout<<scout(ex)<<scout(ey)<<scout(ez);
  //mcout<<scout(r);
  return r;
}

Referenced by down(), and down_new().

operator/()

vec vec::operator/ ( vfloat  p ) const

inline

Definition at line 262 of file vec.h.

{ return vec(x / p, y / p, z / p); }

random_conic_vec()

void vec::random_conic_vec

(

double

theta

)

Definition at line 322 of file vec.cpp.

                                       {
#ifdef USE_SRANLUX
  vfloat phi = M_PI * 2.0 * SRANLUX();
#else
  vfloat phi = M_PI * 2.0 * random_engine.flat();
#endif
  double stheta = sin(theta);
  x = sin(phi) * stheta;
  y = cos(phi) * stheta;
  z = cos(theta);
}

Referenced by Heed::HeedParticle::physics(), and Heed::HeedParticle_BGM::physics().

random_round_vec()

void vec::random_round_vec

(

void

)

Definition at line 311 of file vec.cpp.

                               {
#ifdef USE_SRANLUX
  vfloat phi = M_PI * 2.0 * SRANLUX();
#else
  vfloat phi = M_PI * 2.0 * random_engine.flat();
#endif
  x = sin(phi);
  y = cos(phi);
  z = 0;
}

Referenced by Heed::ElElasticScat::fill_hist_low_scat(), Heed::HeedDeltaElectron::physics_after_new_speed(), and random_sfer_vec().

random_sfer_vec()

void vec::random_sfer_vec

(

void

)

Definition at line 334 of file vec.cpp.

                          {
#ifdef USE_SRANLUX
  vfloat cteta = 2.0 * SRANLUX() - 1.0;
#else
  vfloat cteta = 2.0 * random_engine.flat() - 1.0;
#endif
  random_round_vec();
  vfloat steta = sqrt(1.0 - cteta * cteta);
  *this = (*this) * steta;
  z = cteta;
}

Referenced by Heed::HeedPhoton::physics_after_new_speed().

shift()

void vec::shift ( const vec &  dir )

virtual

Reimplemented from absref.

Definition at line 302 of file vec.cpp.

                            {
  // Not defined for vectors
}

turn()

void vec::turn ( const vec &  dir, vfloat  angle  )

virtual

Reimplemented from absref.

Definition at line 298 of file vec.cpp.

                                           {
  *this = this->turn_new(dir, angle);
}

Referenced by trajestep::Gnextpoint(), trajestep::Gnextpoint1(), Heed::mparticle::new_speed(), Heed::spquadr::pt_angle_rad(), and Heed::splane::range().

turn_new()

vec vec::turn_new	(	const vec &	dir,
		vfloat	angle
	)

Definition at line 271 of file vec.cpp.

                                              {
  pvecerror("vec turn(vec& dir, vfloat& angle)");
  if (length(*this) == 0) return vec(0, 0, 0);
  if (check_par(*this, dir, 0.0) != 0) {
    // parallel vectors are not changed
    return *this;
  }
  vfloat dirlen = length(dir);
  check_econd11a(dirlen, == 0, "cannot turn around zero vector", mcerr);
  vec u = dir / dirlen;  // unit vector
  vec constcomp = u * (*this) * u;
  //vec  perpcomp = (*this) - constcomp;
  //vfloat len=length(perpcomp);
  vec ort1 = unit_vec(u || (*this));
  vec ort2 = ort1 || u;
  vec perpcomp = ort2 * (*this) * ort2;
  vfloat len = length(perpcomp);
  //mcout<<" constcomp="<<constcomp<<" ort1="<<ort1<<" ort2="<<ort2;
  ort1 = sin(angle) * len * ort1;
  ort2 = cos(angle) * len * ort2;
  //mcout<<" constcomp="<<constcomp<<" ort1="<<ort1<<" ort2="<<ort2
  //    <<" len="<<len<<" sin(angle)="<<sin(angle)<<" cos(angle)="<<cos(angle)
  //    <<" angle="<<angle<<'\n';
  return constcomp + ort1 + ort2;
 
}

Referenced by turn().

up() [1/2]

void vec::up ( const abssyscoor *  fasc )

virtual

Reimplemented from absref.

Definition at line 309 of file vec.cpp.

{ up(fasc->Gabas()); }

up() [2/2]

void vec::up

(

const basis *

fabas_new

)

Definition at line 269 of file vec.cpp.

{ *this = this->up_new(fabas_new); }

Referenced by macro_copy_body_not_defined(), up(), and point::up().

up_new() [1/2]

vec vec::up_new

(

const abssyscoor *

fasc

)

Definition at line 308 of file vec.cpp.

{ return up_new(fasc->Gabas()); }

up_new() [2/2]

vec vec::up_new

(

const basis *

fabas_new

)

Definition at line 249 of file vec.cpp.

                                      {
  // it is assumed that fabas_new is derivative from old
  pvecerrorp("vec vec::up_new((const basis *pbas)");
  vec r;
  //check_econd11(fabas_new , ==NULL, mcerr);
  // not compiled in IRIX, reason is unkown
  if (fabas_new == NULL) {
    funnw.ehdr(mcerr);
    mcerr << "fabas_new==NULL\n";
    spexit(mcerr);
  }
  vec ex = fabas_new->Gex();
  vec ey = fabas_new->Gey();
  vec ez = fabas_new->Gez();
  r.x = x * ex.x + y * ex.y + z * ex.z;
  r.y = x * ey.x + y * ey.y + z * ey.z;
  r.z = x * ez.x + y * ez.y + z * ez.z;
  return r;
}

Referenced by up(), and up_new().

Friends And Related Function Documentation

ang2projvec

vfloat ang2projvec ( const vec &  r1, const vec &  r2, const vec &  normal  )

friend

Definition at line 212 of file vec.cpp.

                                                                    {
  pvecerror(
      "vfloat ang2projvec(const vec& r1, const vec& r2, const vec& normal)");
  vec rt1 = project_to_plane(r1, normal);
  vec rt2 = project_to_plane(r2, normal);
  if (rt1 == dv0 || rt2 == dv0) {
    vecerror = 1;
    return 0;
  }
  vfloat tang = ang2vec(rt1, rt2);
  if (tang == 0) return tang;  // projections are parallel
  vec at = rt1 || rt2;
  int i = check_par(at, normal, 0.0001);
  //mcout<<"r1="<<r1<<"r2="<<r2<<"normal="<<normal
  //     <<"rt1="<<rt1<<"rt2="<<rt2<<"\ntang="<<tang
  //     <<"\nat="<<at<<" i="<<i<<'\n';
  if (i == -1) return 2.0 * M_PI - tang;
  return tang;  // it works if angle <= PI
}

ang2vec

vfloat ang2vec ( const vec &  r1, const vec &  r2  )

friend

Definition at line 165 of file vec.cpp.

                                             {
  // angle between vectors
  // instead of return acos(cos2vec(r1,r2)); which produces NaN on linux at
  // parallel vectors
  vfloat cs = cos2vec(r1, r2);
  if (vecerror != 0) return 0;
  if (cs > 0.707106781187 || cs < -0.707106781187) {  // 1.0/sqrt(2)
    // pass to sin, it will be more exactly
    vfloat sn = sin2vec(r1, r2);
    if (vecerror != 0) return 0;
    if (cs > 0.0)
      return asin(sn);
    else
      return M_PI - asin(sn);
  }
  return acos(cs);
}

apeq

wl_inline int apeq ( const vec &  r1, const vec &  r2, vfloat  prec  )

friend

check_par

wl_inline int check_par ( const vec &  r1, const vec &  r2, vfloat  prec  )

friend

Referenced by turn_new().

check_perp

wl_inline int check_perp ( const vec &  r1, const vec &  r2, vfloat  prec  )

friend

cos2vec

vfloat cos2vec ( const vec &  r1, const vec &  r2  )

friend

Definition at line 142 of file vec.cpp.

                                             {
  // cosinus of angle between vectors
  // If one of vectors has zero length, it returns 2.
  pvecerror("vfloat cos2vec(const vec& r1, const vec& r2)");
  vfloat lr1 = length2(r1);
  vfloat lr2 = length2(r2);
  //mcout<<"cos2vec:\n";
  //Iprintn(mcout, lr1);
  //Iprintn(mcout, lr2);
  if (lr1 == 0 || lr2 == 0) {
    vecerror = 1;
    return 0;
  }
  vfloat cs = r1 * r2;
  int sign = 1;
  if (cs < 0) sign = -1;
  cs = cs * cs;
  cs = sign * sqrt(cs / (lr1 * lr2));
  //mcout<<"r1="<<r1<<"r2="<<r2<<"cos="<<cs<<'\n';
  return cs;
  //return r1*r2/(lr1*lr2);
}

length

vfloat length ( const vec &  v )

friend

Definition at line 299 of file vec.h.

                                     {
    return sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
  }

Referenced by turn_new().

length2

vfloat length2 ( const vec &  v )

friend

Definition at line 302 of file vec.h.

                                      {
    return (v.x * v.x + v.y * v.y + v.z * v.z);
  }

not_apeq

wl_inline int not_apeq ( const vec &  r1, const vec &  r2, vfloat  prec  )

friend

operator!=

wl_inline int operator!= ( const vec &  r1, const vec &  r2  )

friend

operator* [1/3]

vfloat operator* ( const vec &  r1, const vec &  r2  )

friend

Definition at line 282 of file vec.h.

                                                        {
    return r1.x * r2.x + r1.y * r2.y + r1.z * r2.z;
  }

operator* [2/3]

vec operator* ( const vec &  v, vfloat  p  )

friend

Definition at line 252 of file vec.h.

                                               {
    return vec(v.x * p, v.y * p, v.z * p);
  }

operator* [3/3]

vec operator* ( vfloat  p, const vec &  v  )

friend

Definition at line 259 of file vec.h.

                                               {
    return vec(v.x * p, v.y * p, v.z * p);
  }

operator*=

vec operator*= ( vec &  v, vfloat  p  )

friend

Definition at line 255 of file vec.h.

                                          {
    v = v * p;
    return v;
  }

operator+

vec operator+ ( const vec &  r1, const vec &  r2  )

friend

Definition at line 267 of file vec.h.

                                                     {
    return vec(r1.x + r2.x, r1.y + r2.y, r1.z + r2.z);
  }

operator+=

vec & operator+= ( vec &  r1, const vec &  r2  )

friend

Definition at line 270 of file vec.h.

                                                 {
    r1 = r1 + r2;
    return r1;
  }

operator- [1/2]

vec operator- ( const vec &  r )

friend

Definition at line 281 of file vec.h.

{ return vec(-r.x, -r.y, -r.z); }

operator- [2/2]

vec operator- ( const vec &  r1, const vec &  r2  )

friend

Definition at line 274 of file vec.h.

                                                     {
    return vec(r1.x - r2.x, r1.y - r2.y, r1.z - r2.z);
  }

operator-=

vec operator-= ( vec &  r1, const vec &  r2  )

friend

Definition at line 277 of file vec.h.

                                                {
    r1 = r1 - r2;
    return r1;
  }

operator/=

vec operator/= ( vec &  v, vfloat  p  )

friend

Definition at line 263 of file vec.h.

                                          {
    v = v / p;
    return v;
  }

operator==

wl_inline int operator== ( const vec &  r1, const vec &  r2  )

friend

operator||

vec operator|| ( const vec &  r1, const vec &  r2  )

friend

Definition at line 286 of file vec.h.

                                                      {
    return vec(r1.y * r2.z - r1.z * r2.y, r1.z * r2.x - r1.x * r2.z,
               r1.x * r2.y - r1.y * r2.x);
  }

project_to_plane

vec project_to_plane ( const vec &  r, const vec &  normal  )

friend

Definition at line 200 of file vec.cpp.

                                                      {
  pvecerror("vec project_to_plane(const vec& r, const vec& normal)");
  vec per(normal || r);
  if (per == dv0) {
    // either one of vectors is 0 or they are parallel
    return dv0;
  }
  vec ax = unit_vec(per || normal);
  vfloat v = ax * r;
  return v * ax;
}

sin2vec

vfloat sin2vec ( const vec &  r1, const vec &  r2  )

friend

Definition at line 183 of file vec.cpp.

                                             {
  // sinus of angle between vectors
  pvecerror("vfloat sin2vec(const vec& r1, const vec& r2)");
  vfloat lr1 = length2(r1);
  vfloat lr2 = length2(r2);
  if (lr1 == 0 || lr2 == 0) {
    vecerror = 1;
    return 0;
  }
  vfloat sn = length(r1 || r2);
  sn = sn * sn;
  sn = sqrt(sn / (lr1 * lr2));
  //mcout<<"r1="<<r1<<"r2="<<r2<<"sin="<<sn<<'\n';
  return sn;
  //return sin(ang2vec(r1,r2));
}

switch_xyz

wl_inline vec switch_xyz ( const vec &  )

friend

unit_vec

wl_inline vec unit_vec ( const vec &  v )

friend

Referenced by turn_new().

Member Data Documentation

x

vfloat vec::x

Definition at line 250 of file vec.h.

Referenced by Heed::box::check_point_inside(), down_new(), Heed::field_map(), Heed::ElElasticScat::fill_hist_low_scat(), Garfield::TrackHeed::GetCluster(), operator/(), operator<<(), Heed::HeedDeltaElectron::physics_after_new_speed(), random_conic_vec(), random_round_vec(), Heed::box::range_ext(), Heed::straight::straight(), Garfield::TrackHeed::TransportPhoton(), up_new(), and vec().

y

vfloat vec::y

Definition at line 250 of file vec.h.

Referenced by Heed::box::check_point_inside(), down_new(), Heed::field_map(), Heed::ElElasticScat::fill_hist_low_scat(), Garfield::TrackHeed::GetCluster(), operator/(), operator<<(), Heed::HeedDeltaElectron::physics_after_new_speed(), random_conic_vec(), random_round_vec(), Heed::box::range_ext(), Heed::straight::straight(), Garfield::TrackHeed::TransportPhoton(), up_new(), vec(), and Heed::straight::vecdistance().

z

vfloat vec::z

Definition at line 250 of file vec.h.

Referenced by Heed::box::check_point_inside(), down_new(), Heed::field_map(), Heed::ElElasticScat::fill_hist_low_scat(), Garfield::TrackHeed::GetCluster(), operator/(), operator<<(), random_conic_vec(), random_round_vec(), random_sfer_vec(), Heed::box::range_ext(), Heed::straight::straight(), Garfield::TrackHeed::TransportPhoton(), up_new(), and vec().

---

The documentation for this class was generated from the following files:

• vec.h
• vec.cpp