Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

EvtTensor3C Class Reference

#include <EvtTensor3C.hh>

List of all members.

Public Member Functions

void applyRotateEuler (double phi, double theta, double ksi)
EvtTensor3C conj () const
EvtVector3C cont1 (const EvtVector3R &v) const
EvtVector3C cont1 (const EvtVector3C &v) const
EvtVector3C cont2 (const EvtVector3R &v) const
EvtVector3C cont2 (const EvtVector3C &v) const
 EvtTensor3C (double d11, double d22, double d33)
 EvtTensor3C (const EvtTensor3C &t1)
 EvtTensor3C ()
const EvtComplex & get (int i, int j) const
EvtTensor3C operator *= (const EvtComplex &c)
EvtTensor3C operator *= (const double d)
EvtTensor3C operator+= (const EvtTensor3C &t2)
EvtTensor3C operator-= (const EvtTensor3C &t2)
EvtTensor3C & operator= (const EvtTensor3C &t1)
void set (int i, int j, const EvtComplex &c)
EvtComplex trace () const
void zero ()
virtual ~EvtTensor3C ()

Static Public Member Functions

const EvtTensor3C & id ()

Private Attributes

EvtComplex t [3][3]

Friends

EvtTensor3C conj (const EvtTensor3C &t2)
EvtTensor3C cont11 (const EvtTensor3C &t1, const EvtTensor3C &t2)
EvtTensor3C cont22 (const EvtTensor3C &t1, const EvtTensor3C &t2)
EvtTensor3C directProd (const EvtVector3R &c1, const EvtVector3R &c2)
EvtTensor3C directProd (const EvtVector3C &c1, const EvtVector3R &c2)
EvtTensor3C directProd (const EvtVector3C &c1, const EvtVector3C &c2)
EvtTensor3C eps (const EvtVector3R &v)
EvtTensor3C operator * (const EvtTensor3C &t2, const double d)
EvtTensor3C operator * (const EvtTensor3C &t2, const EvtComplex &c)
EvtTensor3C operator * (const double d, const EvtTensor3C &t2)
EvtTensor3C operator * (const EvtComplex &c, const EvtTensor3C &t2)
EvtTensor3C operator+ (const EvtTensor3C &t1, const EvtTensor3C &t2)
EvtTensor3C operator- (const EvtTensor3C &t1, const EvtTensor3C &t2)
std::ostream & operator<< (std::ostream &c, const EvtTensor3C &v)
EvtTensor3C rotateEuler (const EvtTensor3C &v, double phi, double theta, double ksi)

Constructor & Destructor Documentation

EvtTensor3C::EvtTensor3C (   ) 
  

00098                         {
00099   
00100   int i,j;
00101   
00102   for(i=0;i<3;i++){
00103     for(j=0;j<3;j++){
00104       t[i][j]=EvtComplex(0.0,0.0);
00105     }
00106   }
00107 
00108 }

EvtTensor3C::EvtTensor3C (  const EvtTensor3C &  t1  ) 
  

00035                                                 {
00036 
00037   int i,j;
00038   
00039   for(i=0;i<3;i++) {
00040     for(j=0;j<3;j++) {
00041       t[i][j] = t1.t[i][j];
00042     }
00043   }
00044 }

EvtTensor3C::EvtTensor3C (  double  d11,
double  d22,
double  d33
) 
  

00046                                                            {
00047 
00048   int i,j;
00049   
00050   for(i=0;i<3;i++) {
00051     for(j=0;j<3;j++) {
00052       t[i][j] = 0.0;
00053     }
00054   }
00055 
00056   t[0][0]=d11;
00057   t[1][1]=d22;
00058   t[2][2]=d33;
00059 
00060 }

EvtTensor3C::~EvtTensor3C (   )  [virtual]
  

00032 {}

Member Function Documentation

void EvtTensor3C::applyRotateEuler (  double  phi,
double  theta,
double  ksi
) 
  

00358                                                                     {
00359 
00360   EvtComplex temp[3][3];
00361   double sp,st,sk,cp,ct,ck;
00362   double r[3][3];
00363   int i,j,k;
00364 
00365   sp=sin(phi);
00366   st=sin(theta);
00367   sk=sin(ksi);
00368   cp=cos(phi);
00369   ct=cos(theta);
00370   ck=cos(ksi);
00371 
00372   r[0][0]=ck*ct*cp-sk*sp;
00373   r[0][1]=ck*ct*sp+sk*cp;
00374   r[0][2]=-ck*st;
00375 
00376   r[1][0]=-sk*ct*cp-ck*sp;
00377   r[1][1]=-sk*ct*sp+ck*cp;
00378   r[1][2]=sk*st;
00379 
00380   r[2][0]=st*cp;
00381   r[2][1]=st*sp;
00382   r[2][2]=ct;
00383 
00384   for(i=0;i<3;i++){
00385     for(j=0;j<3;j++){
00386       temp[i][j]=0.0;
00387       for(k=0;k<3;k++){
00388         temp[i][j]+=r[i][k]*t[k][j];
00389       }
00390     }
00391   }
00392 
00393   for(i=0;i<3;i++){
00394     for(j=0;j<3;j++){
00395       t[i][j]=0.0;
00396       for(k=0;k<3;k++){
00397         t[i][j]+=r[i][k]*temp[j][k];
00398       }
00399     }
00400   }
00401 
00402 
00403 }

EvtTensor3C EvtTensor3C::conj (   )  const
  

00075                                     {
00076   EvtTensor3C temp;
00077   
00078   int i,j;
00079   
00080   for(i=0;i<3;i++) {
00081     for(j=0;j<3;j++) {
00082       temp.set(j,i,::conj(t[i][j]));
00083     }
00084   }
00085   return temp;
00086 }

EvtVector3C EvtTensor3C::cont1 (  const EvtVector3R &  v  )  const
  

00280                                                          {
00281   EvtVector3C temp;
00282   
00283   int i;
00284   
00285   for(i=0;i<3;i++){
00286     temp.set(i,t[0][i]*v.get(0)+t[1][i]*v.get(1)
00287              +t[2][i]*v.get(2));
00288   }
00289 
00290   return temp;
00291 }

EvtVector3C EvtTensor3C::cont1 (  const EvtVector3C &  v  )  const
  

00254                                                          {
00255   EvtVector3C temp;
00256   
00257   int i;
00258   
00259   for(i=0;i<3;i++){
00260     temp.set(i,t[0][i]*v.get(0)+t[1][i]*v.get(1)
00261              +t[2][i]*v.get(2));
00262   }
00263   
00264   return temp;
00265 }

EvtVector3C EvtTensor3C::cont2 (  const EvtVector3R &  v  )  const
  

00293                                                          {
00294   EvtVector3C temp;
00295   
00296   int i;
00297   
00298   for(i=0;i<3;i++){
00299     temp.set(i,t[i][0]*v.get(0)+t[i][1]*v.get(1)
00300              +t[i][2]*v.get(2));
00301   }
00302   
00303   return temp;
00304 }

EvtVector3C EvtTensor3C::cont2 (  const EvtVector3C &  v  )  const
  

00267                                                          {
00268   EvtVector3C temp;
00269 
00270   int i;
00271   
00272   for(i=0;i<3;i++){
00273     temp.set(i,t[i][0]*v.get(0)+t[i][1]*v.get(1)
00274              +t[i][2]*v.get(2));
00275   }
00276   
00277   return temp;
00278 }

const EvtComplex & EvtTensor3C::get (  int  i,
int  j
)  const [inline]
  

00135                                                           {
00136    return t[i][j];
00137 }

const EvtTensor3C & EvtTensor3C::id (   )  [static]
  

00330                                   {
00331 
00332   static EvtTensor3C identity(1.0,1.0,1.0);
00333 
00334   return identity;
00335 
00336 }

EvtTensor3C EvtTensor3C::operator *= (  const EvtComplex &  c  ) 
  

00137                                                        {
00138 
00139   int i,j;
00140   
00141   for (i=0;i<3;i++) {
00142     for (j=0;j<3;j++) {
00143       t[i][j]*=c;
00144     }
00145   }
00146   return *this;
00147 }

EvtTensor3C EvtTensor3C::operator *= (  const double  d  ) 
  

00150                                                  {
00151 
00152   int i,j;
00153   
00154   for (i=0;i<3;i++) {
00155     for (j=0;j<3;j++) {
00156       t[i][j]*=EvtComplex(c);
00157     }
00158   }
00159   return *this;
00160 }

EvtTensor3C EvtTensor3C::operator+= (  const EvtTensor3C &  t2  ) 
  

00110                                                          {
00111   
00112   int i,j;
00113   
00114   for (i=0;i<3;i++) {
00115     for (j=0;j<3;j++) {
00116       t[i][j]+=t2.t[i][j];
00117     }
00118   }
00119   return *this;
00120 }

EvtTensor3C EvtTensor3C::operator-= (  const EvtTensor3C &  t2  ) 
  

00123                                                          {
00124   
00125   int i,j;
00126   
00127   for (i=0;i<3;i++) {
00128     for (j=0;j<3;j++) {
00129       t[i][j]-=t2.t[i][j];
00130     }
00131   }
00132   return *this;
00133 }

EvtTensor3C & EvtTensor3C::operator= (  const EvtTensor3C &  t1  ) 
  

00064                                                          {
00065   int i,j;
00066   
00067   for(i=0;i<3;i++) {
00068     for(j=0;j<3;j++) {
00069       t[i][j] = t1.t[i][j];
00070     }
00071   }
00072   return *this;
00073 }

void EvtTensor3C::set (  int  i,
int  j,
const EvtComplex &  c
)  [inline]
  

00131                                                            {
00132    t[i][j]=c;
00133 }

EvtComplex EvtTensor3C::trace (   )  const [inline]
  

00139                                           {
00140    return t[0][0]+t[1][1]+t[2][2];
00141 }

void EvtTensor3C::zero (   ) 
  

00088                       {
00089   int i,j;
00090   for(i=0;i<3;i++){
00091     for(j=0;j<3;j++){
00092       t[i][j]=EvtComplex(0.0,0.0);
00093     }
00094   }
00095 }

Friends And Related Function Documentation

EvtTensor3C conj (  const EvtTensor3C &  t2  )  [friend]
  

00204                                         { 
00205   EvtTensor3C temp;
00206   
00207   int i,j;
00208 
00209   for(i=0;i<3;i++){ 
00210     for(j=0;j<3;j++){ 
00211       temp.set(i,j,::conj((t2.get(i,j))));
00212     }
00213   }
00214   
00215   return temp;
00216 }

EvtTensor3C cont11 (  const EvtTensor3C &  t1,
const EvtTensor3C &  t2
)  [friend]
  

00236                                                                { 
00237   EvtTensor3C temp;
00238   
00239   int i,j;
00240   EvtComplex c;
00241   
00242   for(i=0;i<3;i++){ 
00243     for(j=0;j<3;j++){ 
00244         c=t1.get(0,i)*t2.get(0,j)+t1.get(1,i)*t2.get(1,j)
00245           +t1.get(2,i)*t2.get(2,j);
00246         temp.set(i,j,c);
00247     }
00248   }
00249   
00250   return temp;
00251 }

EvtTensor3C cont22 (  const EvtTensor3C &  t1,
const EvtTensor3C &  t2
)  [friend]
  

00219                                                                { 
00220   EvtTensor3C temp;
00221 
00222   int i,j;
00223   EvtComplex c;
00224   
00225   for(i=0;i<3;i++){ 
00226     for(j=0;j<3;j++){ 
00227       c=t1.get(i,0)*t2.get(j,0)+t1.get(i,1)*t2.get(j,1)
00228         +t1.get(i,2)*t2.get(j,2);
00229       temp.set(i,j,c);
00230     }
00231   }
00232   
00233   return temp;
00234 }

EvtTensor3C directProd (  const EvtVector3R &  c1,
const EvtVector3R &  c2
)  [friend]
  

00191                                                                    { 
00192   EvtTensor3C temp;
00193   int i,j;
00194   
00195   for (i=0;i<3;i++) {
00196     for (j=0;j<3;j++) {
00197       temp.t[i][j]=EvtComplex(c1.get(i)*c2.get(j),0.0);
00198     }
00199   }
00200   return temp;
00201 }

EvtTensor3C directProd (  const EvtVector3C &  c1,
const EvtVector3R &  c2
)  [friend]
  

00178                                                                    { 
00179   EvtTensor3C temp;
00180   int i,j;
00181   
00182   for (i=0;i<3;i++) {
00183     for (j=0;j<3;j++) {
00184       temp.set(i,j,c1.get(i)*c2.get(j));
00185     }
00186   }
00187   return temp;
00188 }

EvtTensor3C directProd (  const EvtVector3C &  c1,
const EvtVector3C &  c2
)  [friend]
  

00165                                                                    { 
00166   EvtTensor3C temp;
00167   int i,j;
00168   
00169   for (i=0;i<3;i++) {
00170     for (j=0;j<3;j++) {
00171       temp.set(i,j,c1.get(i)*c2.get(j));
00172     }
00173   }
00174   return temp;
00175 }

EvtTensor3C eps (  const EvtVector3R &  v  )  [friend]
  

00307                                      {
00308 
00309   EvtTensor3C temp;
00310 
00311   temp.t[0][0]=0.0;
00312   temp.t[1][1]=0.0;
00313   temp.t[2][2]=0.0;
00314 
00315   temp.t[0][1]=v.get(2);
00316   temp.t[0][2]=-v.get(1);
00317 
00318   temp.t[1][0]=-v.get(2);
00319   temp.t[1][2]=v.get(0);
00320 
00321   temp.t[2][0]=v.get(1);
00322   temp.t[2][1]=-v.get(0);
00323 
00324   return temp;
00325 
00326 }

EvtTensor3C operator * (  const EvtTensor3C &  t2,
const double  d
)  [friend]
 

EvtTensor3C operator * (  const EvtTensor3C &  t2,
const EvtComplex &  c
)  [friend]
 

EvtTensor3C operator * (  const double  d,
const EvtTensor3C &  t2
)  [friend]
 

EvtTensor3C operator * (  const EvtComplex &  c,
const EvtTensor3C &  t2
)  [friend]
 

EvtTensor3C operator+ (  const EvtTensor3C &  t1,
const EvtTensor3C &  t2
)  [friend]
 

EvtTensor3C operator- (  const EvtTensor3C &  t1,
const EvtTensor3C &  t2
)  [friend]
 

std::ostream& operator<< (  std::ostream &  c,
const EvtTensor3C &  v
)  [friend]
 

EvtTensor3C rotateEuler (  const EvtTensor3C &  v,
double  phi,
double  theta,
double  ksi
)  [friend]
  

00349                                                               {
00350 
00351   EvtTensor3C tmp(v);
00352   tmp.applyRotateEuler(alpha,beta,gamma);
00353   return tmp;
00354 
00355 }

Member Data Documentation

EvtComplex EvtTensor3C::t[3][3] [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:12:15 2011 for BOSS6.5.5 by  doxygen 1.3.9.1