Import Geant4 10.6.0 source tree

source/analysis/g4tools/include/tools/lina/MATCOM

@@ -132,6 +132,18 @@ public:\
     }}\
   }\
 public:\
+  template <class ARRAY>\
+  bool mul_array(ARRAY& a_array,T a_tmp[]) const {\
+    /* a_array = this *= a_array */\
+    unsigned int _dim = dimension();\
+    T* pos = a_tmp;\
+    for(unsigned int r=0;r<_dim;r++,pos++) {\
+      *pos = T();\
+      for(unsigned int c=0;c<_dim;c++) *pos += m_vec[r+c*_dim]*a_array[c];\
+    }\
+   {for(unsigned int i=0;i<_dim;i++) a_array[i] = a_tmp[i];}\
+    return true;\
+  }\
   template <class VEC>\
   bool mul_vec(VEC& a_vec,T a_tmp[]) const {\
     /* a_vec = this *= a_vec */\
@@ -147,9 +159,9 @@ public:\
   }\
   template <class VEC>\
   bool mul_vec(VEC& a_vec) const {\
-    T* res = new T[dimension()];\
-    bool status = mul_vec(a_vec,res);\
-    delete [] res;\
+    T* _tmp = new T[dimension()];\
+    bool status = mul_vec(a_vec,_tmp);\
+    delete [] _tmp;\
     return status;\
   }\
 \
@@ -165,9 +177,9 @@ public:\
     return true;\
   }\
   bool mul_array(T a_vec[]) const {\
-    T* res = new T[dimension()];\
-    bool status = mul_array(a_vec,res);\
-    delete [] res;\
+    T* _tmp = new T[dimension()];\
+    bool status = mul_array(a_vec,_tmp);\
+    delete [] _tmp;\
     return status;\
   }\
 \
@@ -225,7 +237,7 @@ public:\
     }\
   }\
 \
-  bool is_proportional(const TOOLS_MAT_CLASS& a_m,const T& a_prec,T& a_factor) const {\
+  bool to_rm_is_proportional(const TOOLS_MAT_CLASS& a_m,const T& a_prec,T& a_factor) const {\
     if(&a_m==this) {a_factor=one();return true;}\
     /* If true, then : a_m = a_factor * this.*/\
     a_factor = zero();\
@@ -235,8 +247,8 @@ public:\
     for(unsigned int i=0;i<dim2();i++,tp++,mp++) {\
              if( ((*tp)==zero()) && ((*mp)==zero())) {\
         continue;\
-      } else if( ((*tp)!=zero()) && ((*mp)==zero())) {\
-        return false;\
+      /*} else if( ((*tp)!=zero()) && ((*mp)==zero())) {\
+        return false;*/\
       } else if( ((*tp)==zero()) && ((*mp)!=zero())) {\
         return false;\
       } else {\
@@ -254,9 +266,8 @@ public:\
   }\
 \
 public:\
-  template <class PREC>\
-  bool is_proportional_prec(const TOOLS_MAT_CLASS& a_right,const PREC& a_prec,PREC(*a_fabs)(const T&),T& a_factor) const {\
-    /* If true, then : a_right = a_factor * this.*/\
+  bool is_proportional(const TOOLS_MAT_CLASS& a_right,T& a_factor) const {\
+    /* If true, then : a_right = a_factor * this. a_factor could be zero.*/\
     if(this==&a_right) {a_factor=T(1);return true;}\
     a_factor = zero();\
     if(dimension()!=a_right.dimension()) return false;\
@@ -265,20 +276,41 @@ public:\
     bool first = true;\
     size_t _data_size = data_size();\
     for(size_t i=0;i<_data_size;i++,lp++,rp++) {\
-             if(  is_zero(*lp,a_prec,a_fabs) &&  is_zero(*rp,a_prec,a_fabs) ) {\
-        continue;\
-      } else if( !is_zero(*lp,a_prec,a_fabs) &&  is_zero(*rp,a_prec,a_fabs) ) {\
+      if(*lp==zero()) {\
+        if(*rp==zero()) continue;\
         return false;\
-      } else if(  is_zero(*lp,a_prec,a_fabs) && !is_zero(*rp,a_prec,a_fabs) ) {\
-        return false;\
-      } else {\
-        if(first) {\
-          a_factor = (*rp)/(*lp);\
-          first = false;\
-        } else {\
-          if(!numbers_are_equal((*lp)*a_factor,*rp,a_prec,a_fabs)) return false;\
-        }\
       }\
+      if(first) {\
+        a_factor = (*rp)/(*lp);\
+        first = false;\
+        continue;\
+      }\
+      if((*lp)*a_factor!=(*rp)) return false;\
+    }\
+    return true;\
+  }\
+\
+  template <class PREC>\
+  bool is_proportional_prec(const TOOLS_MAT_CLASS& a_right,const PREC& a_prec,PREC(*a_fabs)(const T&),T& a_factor) const {\
+    /* If true, then : a_right = a_factor * this. a_factor could be zero.*/\
+    if(this==&a_right) {a_factor=T(1);return true;}\
+    a_factor = zero();\
+    if(dimension()!=a_right.dimension()) return false;\
+    T* lp = (T*)m_vec;\
+    T* rp = (T*)a_right.m_vec;\
+    bool first = true;\
+    size_t _data_size = data_size();\
+    for(size_t i=0;i<_data_size;i++,lp++,rp++) {\
+      if(is_zero(*lp,a_prec,a_fabs)) {\
+        if(is_zero(*rp,a_prec,a_fabs)) continue;\
+        return false;\
+      }\
+      if(first) {\
+        a_factor = (*rp)/(*lp);\
+        first = false;\
+        continue;\
+      }\
+      if(!numbers_are_equal((*lp)*a_factor,*rp,a_prec,a_fabs)) return false;\
     }\
     return true;\
   }\
@@ -392,7 +424,7 @@ public:\
                                                  |0 Y|*/\
     unsigned int _D = dimension();\
     unsigned int _D_2 = _D/2;\
-    /*if(2*__D_2!=_D) return false;*/\
+    if(2*_D_2!=_D) return false;\
     for(unsigned int r=0;r<_D_2;r++) {\
       for(unsigned int c=_D_2;c<_D;c++) {\
         if(a_fabs(value(r,c))>=a_prec) return false;\
@@ -412,7 +444,7 @@ public:\
                                                  |Y 0|*/\
     unsigned int _D = dimension();\
     unsigned int _D_2 = _D/2;\
-    /*if(2*__D_2!=_D) return false;*/\
+    if(2*_D_2!=_D) return false;\
     for(unsigned int r=0;r<_D_2;r++) {\
       for(unsigned int c=0;c<_D_2;c++) {\
         if(a_fabs(value(r,c))>=a_prec) return false;\
@@ -425,6 +457,26 @@ public:\
     }\
     return true;\
   }\
+\
+  template <class PREC>\
+  bool is_decomplex(const PREC& a_prec,PREC(*a_fabs)(const T&)) const {\
+    /* Look if even dim matrix is of the form :  | X Y|\
+                                                 |-Y X|*/\
+    unsigned int _D = dimension();\
+    unsigned int _D_2 = _D/2;\
+    if(2*_D_2!=_D) return false;\
+    for(unsigned int r=0;r<_D_2;r++) {\
+      for(unsigned int c=0;c<_D_2;c++) {\
+        if(a_fabs(value(r,c)-value(r+_D_2,c+_D_2))>=a_prec) return false;\
+      }\
+    }\
+    for(unsigned int r=0;r<_D_2;r++) {\
+      for(unsigned int c=_D_2;c<_D;c++) {\
+        if(a_fabs(value(r,c)+value(r+_D_2,c-_D_2))>=a_prec) return false;\
+      }\
+    }\
+    return true;\
+  }\
 \
   template <class PREC>\
   T determinant_prec(unsigned int a_tmp_rs[],unsigned int a_tmp_cs[],  /*[rord=dim-1]*/\
@@ -727,21 +779,31 @@ public:\
 \
   void power(unsigned int a_n,TOOLS_MAT_CLASS& a_res) const {\
     a_res.set_identity();\
+    T* _tmp = new T[dim2()];\
     for(unsigned int i=0;i<a_n;i++) {\
-      a_res._mul_mtx(m_vec);\
+      a_res._mul_mtx(m_vec,_tmp);\
+    }\
+    delete [] _tmp;\
+  }\
+\
+  void exp(unsigned int a_le,TOOLS_MAT_CLASS& a_res,TOOLS_MAT_CLASS& a_tmp,T a_tmp_2[]) const { /*OPTIMIZATION*/\
+    /* result = I + M + M**2/2! + M**3/3! + .... */\
+    a_res.set_identity();\
+    a_tmp.set_identity();\
+    for(unsigned int i=1;i<=a_le;i++) {\
+      a_tmp._mul_mtx(m_vec,a_tmp_2);\
+      a_tmp.multiply(one()/T(i));\
+      a_res += a_tmp;\
     }\
   }\
 \
   void exp(unsigned int a_le,TOOLS_MAT_CLASS& a_res) const {\
     /* result = I + M + M**2/2! + M**3/3! + .... */\
-    a_res.set_identity();\
     TOOLS_MAT_CLASS tmp(*this);\
     tmp.set_identity();\
-    for(unsigned int i=1;i<=a_le;i++) {\
-      tmp._mul_mtx(m_vec);\
-      tmp.multiply(one()/T(i)); \
-      a_res += tmp;\
-    }\
+    T* tmp_2 = new T[dim2()];\
+    exp(a_le,a_res,tmp,tmp_2);\
+    delete [] tmp_2;\
   }\
 \
   void cosh(unsigned int a_le,TOOLS_MAT_CLASS& a_res) const {\
@@ -751,12 +813,14 @@ public:\
     M_2._mul_mtx(m_vec);\
     TOOLS_MAT_CLASS tmp(*this);\
     tmp.set_identity();\
+    T* _tmp = new T[dim2()];\
     for(unsigned int i=1;i<=a_le;i+=2) {\
-      tmp *= M_2;\
+      tmp._mul_mtx(M_2.m_vec,_tmp);\
       tmp.multiply(one()/T(i+0)); \
       tmp.multiply(one()/T(i+1)); \
       a_res += tmp;\
     }\
+    delete [] _tmp;\
   }\
 \
   void sinh(unsigned int a_le,TOOLS_MAT_CLASS& a_res) const {\
@@ -766,12 +830,14 @@ public:\
     M_2._mul_mtx(m_vec);\
     TOOLS_MAT_CLASS tmp(*this);\
     tmp._copy(m_vec);\
+    T* _tmp = new T[dim2()];\
     for(unsigned int i=1;i<=a_le;i+=2) {\
-      tmp *= M_2;\
+      tmp._mul_mtx(M_2.m_vec,_tmp);\
       tmp.multiply(one()/T(i+1)); \
       tmp.multiply(one()/T(i+2)); \
       a_res += tmp;\
     }\
+    delete [] _tmp;\
   }\
 \
   void log(unsigned int a_le,TOOLS_MAT_CLASS& a_res) const {\
@@ -789,14 +855,37 @@ public:\
 \
     TOOLS_MAT_CLASS tmp;\
 \
+    T* _tmp = new T[dim2()];\
     for(unsigned int i=0;i<=a_le;i++) {\
       fact *= minus_one();      \
       tmp = M_Ip;\
       tmp.multiply(fact/T(i+1)); \
       a_res += tmp;\
-      M_Ip._mul_mtx(M_I.m_vec);\
+      M_Ip._mul_mtx(M_I.m_vec,_tmp);\
+    }\
+    delete [] _tmp;\
+  }\
+\
+  void omega(unsigned int a_le,TOOLS_MAT_CLASS& a_res,TOOLS_MAT_CLASS& a_tmp,T a_tmp_2[]) const { /*OPTIMIZATION*/\
+    /* result = I + M/2! + M**2/3! + M**3/4! + .... */\
+    a_res.set_identity();\
+    a_tmp.set_identity();\
+    for(unsigned int i=1;i<=a_le;i++) {\
+      a_tmp._mul_mtx(m_vec,a_tmp_2);\
+      a_tmp.multiply(one()/T(i+1));\
+      a_res += a_tmp;\
     }\
   }\
+\
+  void omega(unsigned int a_le,TOOLS_MAT_CLASS& a_res) const {\
+    /* result = I + M/2! + M**2/3! + M**3/4! + .... */\
+    TOOLS_MAT_CLASS tmp(*this);\
+    tmp.set_identity();\
+    T* tmp_2 = new T[dim2()];\
+    omega(a_le,a_res,tmp,tmp_2);\
+    delete [] tmp_2;\
+  }\
+\
   template <class MAT>\
   bool copy(const MAT& a_from) {\
     /*for exa from a double matrix to a symbol matrix*/\
@@ -914,26 +1003,26 @@ protected:\
   }\
 \
   void _mul_mtx(const T a_m[]) {\
-    T* res = new T[dim2()];\
-    _mul_mtx(a_m,res);\
-    delete [] res;\
+    T* _tmp = new T[dim2()];\
+    _mul_mtx(a_m,_tmp);\
+    delete [] _tmp;\
   }\
 \
   void _left_mul_mtx(const T a_m[]) {\
     /* this = a_m * this */\
     unsigned int _D = dimension();\
-    T* res = new T[dim2()];\
+    T* _tmp = new T[dim2()];\
     for(unsigned int r=0;r<_D;r++) {\
       for(unsigned int c=0;c<_D;c++) {\
         T _value = zero();\
         for(unsigned int i=0;i<_D;i++) {\
           _value += (*(a_m+r+i*_D)) * (*(m_vec+i+c*_D)); /*optimize.*/\
         }\
-        *(res+r+c*_D) = _value;\
+        *(_tmp+r+c*_D) = _value;\
       }\
     }\
-    _copy(res);\
-    delete [] res;\
+    _copy(_tmp);\
+    delete [] _tmp;\
   }\
 \
   template <class PREC>\

source/analysis/g4tools/include/tools/lina/eqT

@@ -19,6 +19,40 @@ inline bool is_zero(const NUMBER& a_left,const PREC& a_prec,PREC(*a_fabs)(const
   return true;
 }
 
+template <class VEC,class PREC>
+inline bool vectors_are_equal(const VEC& a_1,const VEC& a_2,const PREC& a_prec,PREC(*a_fabs)(const PREC&)) {
+  if(a_1.size()!=a_2.size()) return false;
+  typedef typename VEC::size_type sz_t;
+  sz_t sz = a_1.size();
+  //bool status = true;
+  for(sz_t index=0;index<sz;index++) {
+    if(!numbers_are_equal(a_1[index],a_2[index],a_prec,a_fabs))
+    //{ ::printf("debug : vectors_are_equals : %lu : %g %g\n",index,a_1[index],a_2[index]);
+      return false;
+      //status = false;
+    //}
+  }
+  return true;
+  //return status;
+}
+
+template <class VECVEC,class PREC>
+inline bool vecvecs_are_equal(const VECVEC& a_1,const VECVEC& a_2,const PREC& a_prec,PREC(*a_fabs)(const PREC&)) {
+  if(a_1.size()!=a_2.size()) return false;
+  typedef typename VECVEC::size_type sz_t;
+  sz_t sz = a_1.size();
+  for(sz_t index=0;index<sz;index++) {
+    if(!vectors_are_equal(a_1[index],a_2[index],a_prec,a_fabs)) return false;
+  }
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/// PREC(*a_fabs)(PREC) : /////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// for histo equals functions.
+
 template <class NUMBER,class PREC>
 inline bool numbers_are_equal(const NUMBER& a_left,const NUMBER& a_right,const PREC& a_prec,PREC(*a_fabs)(NUMBER)) {
   NUMBER diff = a_left - a_right;
@@ -54,6 +88,10 @@ inline bool vecvecs_are_equal(const VECVEC& a_1,const VECVEC& a_2,const PREC& a_
   return true;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 
 #endif

source/analysis/g4tools/include/tools/lina/mat

@@ -232,6 +232,18 @@ inline bool to_real(const CMAT& a_c,RMAT& a_r,typename CMAT::elem_t::value_type
   return true;
 }
 
+template <class RMAT,class CMAT> 
+inline bool to_complex(const RMAT& a_r,CMAT& a_c) {
+  if(a_c.dimension()!=a_r.dimension()) return false;
+  typedef typename RMAT::elem_t RT;
+  const RT* rpos = a_r.data();
+  typedef typename CMAT::elem_t CT;
+  CT* cpos = const_cast<CT*>(a_c.data());
+  unsigned int D2 = a_r.dimension()*a_r.dimension();
+  for(unsigned int i=0;i<D2;i++,rpos++,cpos++) *cpos = CT(*rpos);
+  return true;
+}
+
 template <class MAT> 
 inline void dagger(MAT& a_m,typename MAT::elem_t (*a_conj)(const typename MAT::elem_t&)) {
   conjugate<MAT>(a_m,a_conj);
@@ -454,18 +466,52 @@ inline nmat<T> operator*(const nmat<T>& a_m,const T& a_fac) {
 }
 */
 
+template <class MAT,class REAL> 
+inline bool mat_fabs(const MAT& a_in,MAT& a_ou,REAL(*a_fabs)(const typename MAT::elem_t&)) {
+  if(a_in.dimension()!=a_ou.dimension()) {a_ou.set_zero();return false;}
+  typedef typename MAT::elem_t T;
+  T* in_pos = const_cast<T*>(a_in.data());
+  T* ou_pos = const_cast<T*>(a_ou.data());
+  unsigned int D2 = a_in.dimension()*a_in.dimension();
+  for(unsigned int i=0;i<D2;i++,in_pos++,ou_pos++) {*ou_pos = a_fabs(*in_pos);}
+  return true;
 }
 
+}
+
+/*
+#include <cstdarg>
+
 namespace tools {
 
+template <class MAT>
+inline void matrix_va_set(MAT& a_m,size_t a_dummy,...) {
+  typedef typename MAT::elem_t T;
+  va_list args;
+  va_start(args,a_dummy);
+  unsigned int D = a_m.dimension();
+  for(unsigned int r=0;r<D;r++) {
+    for(unsigned int c=0;c<D;c++) {
+      a_m.set_value(r,c,va_arg(args,T));
+    }
+  }
+  va_end(args);
+}
+
+}
+*/
+
+namespace tools {
+
+#define TOOLS_MELEM const typename MAT::elem_t&
+
 ////////////////////////////////////////////////
 /// specific D=2 ///////////////////////////////
 ////////////////////////////////////////////////
-
 template <class MAT>
 inline void matrix_set(MAT& a_m
-,const typename MAT::elem_t& a_00,const typename MAT::elem_t& a_01
-,const typename MAT::elem_t& a_10,const typename MAT::elem_t& a_11
+,TOOLS_MELEM a_00,TOOLS_MELEM a_01
+,TOOLS_MELEM a_10,TOOLS_MELEM a_11
 ){
   //a_<R><C>
   //vec[R + C * 2];
@@ -479,9 +525,9 @@ inline void matrix_set(MAT& a_m
 ////////////////////////////////////////////////
 template <class MAT>
 inline void matrix_set(MAT& a_m
-,const typename MAT::elem_t& a_00,const typename MAT::elem_t& a_01,const typename MAT::elem_t& a_02 //1 row
-,const typename MAT::elem_t& a_10,const typename MAT::elem_t& a_11,const typename MAT::elem_t& a_12 //2 row
-,const typename MAT::elem_t& a_20,const typename MAT::elem_t& a_21,const typename MAT::elem_t& a_22 //3 row
+,TOOLS_MELEM a_00,TOOLS_MELEM a_01,TOOLS_MELEM a_02 //1 row
+,TOOLS_MELEM a_10,TOOLS_MELEM a_11,TOOLS_MELEM a_12 //2 row
+,TOOLS_MELEM a_20,TOOLS_MELEM a_21,TOOLS_MELEM a_22 //3 row
 ){
   //a_<R><C>
   //vec[R + C * 3];
@@ -496,10 +542,10 @@ inline void matrix_set(MAT& a_m
 ////////////////////////////////////////////////
 template <class MAT>
 inline void matrix_set(MAT& a_m
-,const typename MAT::elem_t& a_00,const typename MAT::elem_t& a_01,const typename MAT::elem_t& a_02,const typename MAT::elem_t& a_03 //1 row
-,const typename MAT::elem_t& a_10,const typename MAT::elem_t& a_11,const typename MAT::elem_t& a_12,const typename MAT::elem_t& a_13 //2 row
-,const typename MAT::elem_t& a_20,const typename MAT::elem_t& a_21,const typename MAT::elem_t& a_22,const typename MAT::elem_t& a_23 //3 row
-,const typename MAT::elem_t& a_30,const typename MAT::elem_t& a_31,const typename MAT::elem_t& a_32,const typename MAT::elem_t& a_33 //4 row
+,TOOLS_MELEM a_00,TOOLS_MELEM a_01,TOOLS_MELEM a_02,TOOLS_MELEM a_03 //1 row
+,TOOLS_MELEM a_10,TOOLS_MELEM a_11,TOOLS_MELEM a_12,TOOLS_MELEM a_13 //2 row
+,TOOLS_MELEM a_20,TOOLS_MELEM a_21,TOOLS_MELEM a_22,TOOLS_MELEM a_23 //3 row
+,TOOLS_MELEM a_30,TOOLS_MELEM a_31,TOOLS_MELEM a_32,TOOLS_MELEM a_33 //4 row
 ){
   //a_<R><C>
   //vec[R + C * 4];
@@ -515,11 +561,11 @@ inline void matrix_set(MAT& a_m
 ////////////////////////////////////////////////
 template <class MAT>
 inline void matrix_set(MAT& a_m
-,const typename MAT::elem_t& a_00,const typename MAT::elem_t& a_01,const typename MAT::elem_t& a_02,const typename MAT::elem_t& a_03,const typename MAT::elem_t& a_04 //1 row
-,const typename MAT::elem_t& a_10,const typename MAT::elem_t& a_11,const typename MAT::elem_t& a_12,const typename MAT::elem_t& a_13,const typename MAT::elem_t& a_14 //2 row
-,const typename MAT::elem_t& a_20,const typename MAT::elem_t& a_21,const typename MAT::elem_t& a_22,const typename MAT::elem_t& a_23,const typename MAT::elem_t& a_24 //3 row
-,const typename MAT::elem_t& a_30,const typename MAT::elem_t& a_31,const typename MAT::elem_t& a_32,const typename MAT::elem_t& a_33,const typename MAT::elem_t& a_34 //4 row
-,const typename MAT::elem_t& a_40,const typename MAT::elem_t& a_41,const typename MAT::elem_t& a_42,const typename MAT::elem_t& a_43,const typename MAT::elem_t& a_44 //5 row
+,TOOLS_MELEM a_00,TOOLS_MELEM a_01,TOOLS_MELEM a_02,TOOLS_MELEM a_03,TOOLS_MELEM a_04 //1 row
+,TOOLS_MELEM a_10,TOOLS_MELEM a_11,TOOLS_MELEM a_12,TOOLS_MELEM a_13,TOOLS_MELEM a_14 //2 row
+,TOOLS_MELEM a_20,TOOLS_MELEM a_21,TOOLS_MELEM a_22,TOOLS_MELEM a_23,TOOLS_MELEM a_24 //3 row
+,TOOLS_MELEM a_30,TOOLS_MELEM a_31,TOOLS_MELEM a_32,TOOLS_MELEM a_33,TOOLS_MELEM a_34 //4 row
+,TOOLS_MELEM a_40,TOOLS_MELEM a_41,TOOLS_MELEM a_42,TOOLS_MELEM a_43,TOOLS_MELEM a_44 //5 row
 ){
   //a_<R><C>
   //vec[R + C * 5];
@@ -536,12 +582,12 @@ inline void matrix_set(MAT& a_m
 ////////////////////////////////////////////////
 template <class MAT>
 inline void matrix_set(MAT& a_m
-,const typename MAT::elem_t& a_00,const typename MAT::elem_t& a_01,const typename MAT::elem_t& a_02,const typename MAT::elem_t& a_03,const typename MAT::elem_t& a_04,const typename MAT::elem_t& a_05 //1 row
-,const typename MAT::elem_t& a_10,const typename MAT::elem_t& a_11,const typename MAT::elem_t& a_12,const typename MAT::elem_t& a_13,const typename MAT::elem_t& a_14,const typename MAT::elem_t& a_15 //2 row
-,const typename MAT::elem_t& a_20,const typename MAT::elem_t& a_21,const typename MAT::elem_t& a_22,const typename MAT::elem_t& a_23,const typename MAT::elem_t& a_24,const typename MAT::elem_t& a_25 //3 row
-,const typename MAT::elem_t& a_30,const typename MAT::elem_t& a_31,const typename MAT::elem_t& a_32,const typename MAT::elem_t& a_33,const typename MAT::elem_t& a_34,const typename MAT::elem_t& a_35 //4 row
-,const typename MAT::elem_t& a_40,const typename MAT::elem_t& a_41,const typename MAT::elem_t& a_42,const typename MAT::elem_t& a_43,const typename MAT::elem_t& a_44,const typename MAT::elem_t& a_45 //5 row
-,const typename MAT::elem_t& a_50,const typename MAT::elem_t& a_51,const typename MAT::elem_t& a_52,const typename MAT::elem_t& a_53,const typename MAT::elem_t& a_54,const typename MAT::elem_t& a_55 //6 row
+,TOOLS_MELEM a_00,TOOLS_MELEM a_01,TOOLS_MELEM a_02,TOOLS_MELEM a_03,TOOLS_MELEM a_04,TOOLS_MELEM a_05 //1 row
+,TOOLS_MELEM a_10,TOOLS_MELEM a_11,TOOLS_MELEM a_12,TOOLS_MELEM a_13,TOOLS_MELEM a_14,TOOLS_MELEM a_15 //2 row
+,TOOLS_MELEM a_20,TOOLS_MELEM a_21,TOOLS_MELEM a_22,TOOLS_MELEM a_23,TOOLS_MELEM a_24,TOOLS_MELEM a_25 //3 row
+,TOOLS_MELEM a_30,TOOLS_MELEM a_31,TOOLS_MELEM a_32,TOOLS_MELEM a_33,TOOLS_MELEM a_34,TOOLS_MELEM a_35 //4 row
+,TOOLS_MELEM a_40,TOOLS_MELEM a_41,TOOLS_MELEM a_42,TOOLS_MELEM a_43,TOOLS_MELEM a_44,TOOLS_MELEM a_45 //5 row
+,TOOLS_MELEM a_50,TOOLS_MELEM a_51,TOOLS_MELEM a_52,TOOLS_MELEM a_53,TOOLS_MELEM a_54,TOOLS_MELEM a_55 //6 row
 ){
   //a_<R><C>
   //vec[R + C * 6];
@@ -554,6 +600,40 @@ inline void matrix_set(MAT& a_m
   vec[5] = a_50;vec[11] = a_51;vec[17] = a_52;vec[23] = a_53;vec[29] = a_54;vec[35] = a_55;
 }
 
+////////////////////////////////////////////////
+/// specific D=10 //////////////////////////////
+////////////////////////////////////////////////
+template <class MAT>
+inline void matrix_set(MAT& a_m
+,TOOLS_MELEM a_00,TOOLS_MELEM a_01,TOOLS_MELEM a_02,TOOLS_MELEM a_03,TOOLS_MELEM a_04,TOOLS_MELEM a_05,TOOLS_MELEM a_06,TOOLS_MELEM a_07,TOOLS_MELEM a_08,TOOLS_MELEM a_09 //1 row
+,TOOLS_MELEM a_10,TOOLS_MELEM a_11,TOOLS_MELEM a_12,TOOLS_MELEM a_13,TOOLS_MELEM a_14,TOOLS_MELEM a_15,TOOLS_MELEM a_16,TOOLS_MELEM a_17,TOOLS_MELEM a_18,TOOLS_MELEM a_19 //2 row
+,TOOLS_MELEM a_20,TOOLS_MELEM a_21,TOOLS_MELEM a_22,TOOLS_MELEM a_23,TOOLS_MELEM a_24,TOOLS_MELEM a_25,TOOLS_MELEM a_26,TOOLS_MELEM a_27,TOOLS_MELEM a_28,TOOLS_MELEM a_29 //3 row
+,TOOLS_MELEM a_30,TOOLS_MELEM a_31,TOOLS_MELEM a_32,TOOLS_MELEM a_33,TOOLS_MELEM a_34,TOOLS_MELEM a_35,TOOLS_MELEM a_36,TOOLS_MELEM a_37,TOOLS_MELEM a_38,TOOLS_MELEM a_39 //4 row
+,TOOLS_MELEM a_40,TOOLS_MELEM a_41,TOOLS_MELEM a_42,TOOLS_MELEM a_43,TOOLS_MELEM a_44,TOOLS_MELEM a_45,TOOLS_MELEM a_46,TOOLS_MELEM a_47,TOOLS_MELEM a_48,TOOLS_MELEM a_49 //5 row
+,TOOLS_MELEM a_50,TOOLS_MELEM a_51,TOOLS_MELEM a_52,TOOLS_MELEM a_53,TOOLS_MELEM a_54,TOOLS_MELEM a_55,TOOLS_MELEM a_56,TOOLS_MELEM a_57,TOOLS_MELEM a_58,TOOLS_MELEM a_59 //6 row
+,TOOLS_MELEM a_60,TOOLS_MELEM a_61,TOOLS_MELEM a_62,TOOLS_MELEM a_63,TOOLS_MELEM a_64,TOOLS_MELEM a_65,TOOLS_MELEM a_66,TOOLS_MELEM a_67,TOOLS_MELEM a_68,TOOLS_MELEM a_69 //7 row
+,TOOLS_MELEM a_70,TOOLS_MELEM a_71,TOOLS_MELEM a_72,TOOLS_MELEM a_73,TOOLS_MELEM a_74,TOOLS_MELEM a_75,TOOLS_MELEM a_76,TOOLS_MELEM a_77,TOOLS_MELEM a_78,TOOLS_MELEM a_79 //8 row
+,TOOLS_MELEM a_80,TOOLS_MELEM a_81,TOOLS_MELEM a_82,TOOLS_MELEM a_83,TOOLS_MELEM a_84,TOOLS_MELEM a_85,TOOLS_MELEM a_86,TOOLS_MELEM a_87,TOOLS_MELEM a_88,TOOLS_MELEM a_89 //9 row
+,TOOLS_MELEM a_90,TOOLS_MELEM a_91,TOOLS_MELEM a_92,TOOLS_MELEM a_93,TOOLS_MELEM a_94,TOOLS_MELEM a_95,TOOLS_MELEM a_96,TOOLS_MELEM a_97,TOOLS_MELEM a_98,TOOLS_MELEM a_99 //10 row
+
+){
+  //a_<R><C>
+  //vec[R + C * 10];
+  typename MAT::elem_t* vec = const_cast<typename MAT::elem_t*>(a_m.data());
+  vec[0] = a_00;vec[10] = a_01;vec[20] = a_02;vec[30] = a_03;vec[40] = a_04;vec[50] = a_05;vec[60] = a_06;vec[70] = a_07;vec[80] = a_08;vec[90] = a_09;
+  vec[1] = a_10;vec[11] = a_11;vec[21] = a_12;vec[31] = a_13;vec[41] = a_14;vec[51] = a_15;vec[61] = a_16;vec[71] = a_17;vec[81] = a_18;vec[91] = a_19;
+  vec[2] = a_20;vec[12] = a_21;vec[22] = a_22;vec[32] = a_23;vec[42] = a_24;vec[52] = a_25;vec[62] = a_26;vec[72] = a_27;vec[82] = a_28;vec[92] = a_29;
+  vec[3] = a_30;vec[13] = a_31;vec[23] = a_32;vec[33] = a_33;vec[43] = a_34;vec[53] = a_35;vec[63] = a_36;vec[73] = a_37;vec[83] = a_38;vec[93] = a_39;
+  vec[4] = a_40;vec[14] = a_41;vec[24] = a_42;vec[34] = a_43;vec[44] = a_44;vec[54] = a_45;vec[64] = a_46;vec[74] = a_47;vec[84] = a_48;vec[94] = a_49;
+  vec[5] = a_50;vec[15] = a_51;vec[25] = a_52;vec[35] = a_53;vec[45] = a_54;vec[55] = a_55;vec[65] = a_56;vec[75] = a_57;vec[85] = a_58;vec[95] = a_59;
+  vec[6] = a_60;vec[16] = a_61;vec[26] = a_62;vec[36] = a_63;vec[46] = a_64;vec[56] = a_65;vec[66] = a_66;vec[76] = a_67;vec[86] = a_68;vec[96] = a_69;
+  vec[7] = a_70;vec[17] = a_71;vec[27] = a_72;vec[37] = a_73;vec[47] = a_74;vec[57] = a_75;vec[67] = a_76;vec[77] = a_77;vec[87] = a_78;vec[97] = a_79;
+  vec[8] = a_80;vec[18] = a_81;vec[28] = a_82;vec[38] = a_83;vec[48] = a_84;vec[58] = a_85;vec[68] = a_86;vec[78] = a_87;vec[88] = a_88;vec[98] = a_89;
+  vec[9] = a_90;vec[19] = a_91;vec[29] = a_92;vec[39] = a_93;vec[49] = a_94;vec[59] = a_95;vec[69] = a_96;vec[79] = a_97;vec[89] = a_98;vec[99] = a_99;
+}
+
+#undef TOOLS_MELEM
+
 }
 
 ////////////////////////////////////////////////

source/analysis/g4tools/include/tools/lina/mat4

@@ -40,9 +40,7 @@ public:
                a_30,a_31,a_32,a_33);
   }
 public:
-  void set_matrix(const mat4<T>& a_m){
-    parent::set_matrix(a_m);
-  }
+  void set_matrix(const mat4<T>& a_m) {parent::set_matrix(a_m);}
   void set_matrix(
     const T& a_00,const T& a_01,const T& a_02,const T& a_03, //1 row
     const T& a_10,const T& a_11,const T& a_12,const T& a_13, //2 row
@@ -57,15 +55,9 @@ public:
     pr::m_vec[3] = a_30;pr::m_vec[7] = a_31;pr::m_vec[11] = a_32;pr::m_vec[15] = a_33;
   }
 
-  void set_scale(const T& a_s) {
-    _set_scale(a_s,a_s,a_s,pr::m_vec);
-  }
-  void set_scale(const T& a_1,const T& a_2,const T& a_3) {
-    _set_scale(a_1,a_2,a_3,pr::m_vec);
-  }
-  void set_translate(const T& a_x,const T& a_y,const T& a_z) {
-    _set_translate(a_x,a_y,a_z,pr::m_vec);
-  }
+  void set_scale(const T& a_s) {_set_scale(a_s,a_s,a_s,pr::m_vec);}
+  void set_scale(const T& a_1,const T& a_2,const T& a_3) {_set_scale(a_1,a_2,a_3,pr::m_vec);}
+  void set_translate(const T& a_x,const T& a_y,const T& a_z) {_set_translate(a_x,a_y,a_z,pr::m_vec);}
   void set_rotate(const T& a_x,const T& a_y,const T& a_z,const T& a_angle,T(*a_sin)(T),T(*a_cos)(T)) {
     _set_rotate(a_x,a_y,a_z,a_angle,pr::m_vec,a_sin,a_cos);
   }
@@ -231,9 +223,7 @@ public:
   }
 
   template <class VEC>
-  void mul_dir_3(VEC& a_dir) const {
-    mul_dir_3(a_dir[0],a_dir[1],a_dir[2]);
-  }
+  void mul_dir_3(VEC& a_dir) const {mul_dir_3(a_dir[0],a_dir[1],a_dir[2]);}
 
   void mul_scale(const T& a_sx,const T& a_sy,const T& a_sz) {
     // this = this * mat4_scale(a_s[x,y,z]
@@ -361,6 +351,7 @@ protected:
 
   static void _set_rotate(const T& a_x,const T& a_y,const T& a_z,const T& a_angle,T v[],T(*a_sin)(T),T(*a_cos)(T)) {
     //WARNING : (a_x,a_y,a_z) must be a normalized vector.
+    // v[] = exp(-a_angle*n(a_x,a_y,a_z)*Rs). It models the rotation of an object in the same coordinate system (active rotation).
     T si = a_sin(a_angle);    
     T co = a_cos(a_angle);    
     T x = a_x;
@@ -389,7 +380,7 @@ protected:
     //
     // R(r,c) = cos(theta)*Id(r,c)+(1-cos(theta))*nr*nc-sin(theta)*(n.E)(r,c)
     //
-    // R = exp(-theta*(n.E))
+    // R = exp(-theta*(n.E)) // active rotation (it models the rotation of an object by theta along n).
 
   }
 

source/analysis/g4tools/include/tools/lina/mat4f

@@ -37,6 +37,7 @@ public:
   }
 public:
   void set_rotate(const float& a_x,const float& a_y,const float& a_z,const float& a_angle) {
+    //WARNING : (a_x,a_y,a_z) must be a normalized vector.
     parent::set_rotate(a_x,a_y,a_z,a_angle,::sinf,::cosf);
   }
   void mul_rotate(const float& a_x,const float& a_y,const float& a_z,const float& a_angle) {
@@ -45,6 +46,13 @@ public:
   void left_mul_rotate(const float& a_x,const float& a_y,const float& a_z,const float& a_angle) {
     parent::left_mul_rotate(a_x,a_y,a_z,a_angle,::sinf,::cosf);
   }
+
+  template <class VEC>
+  void set_rotate(const VEC& a_dir,float a_angle) {
+    //WARNING : a_dir must be a normalized vector.
+    parent::set_rotate(a_dir[0],a_dir[1],a_dir[2],a_angle,::sinf,::cosf);
+  }
+
 public: //backward compatibility
   void mul_2f(float& a_x,float& a_y) const {parent::mul_2(a_x,a_y);}
   void mul_3f(float& a_x,float& a_y,float& a_z) const {parent::mul_3(a_x,a_y,a_z);}

source/analysis/g4tools/include/tools/lina/qrot

@@ -123,6 +123,8 @@ public:
 
   bool set_value(const VEC3& a_from,const VEC3& a_to,T(*a_sqrt)(T),T(*a_fabs)(T)) {
     // code taken from coin3d/SbRotation.
+    //NOTE : coin3d/SbMatrix logic is transposed relative to us.
+    
     VEC3 from(a_from);
     if(from.normalize()==T()) return false;
     VEC3 to(a_to);
@@ -163,16 +165,16 @@ public:
 
   bool value(VEC3& a_axis,T& a_radians,T(*a_sin)(T),T(*a_acos)(T)) const { //WARNING a_acos and NOT a_cos
     //WARNING : can fail.
-    if( (m_quat.v3()<minus_one()) || (m_quat.v3()> one()) ){ ////???
+    if( (m_quat.v3()<minus_one()) || (m_quat.v3()> one()) ) {
       a_axis.set_value(0,0,1);
       a_radians = 0;
       return false;
     }
 
-    a_radians = a_acos(m_quat.v3()) * 2;
+    a_radians = a_acos(m_quat.v3()) * 2; //in [0,2*pi]
     T sineval = a_sin(a_radians/2);
 
-    if(sineval==T()) { //???
+    if(sineval==T()) { //a_radian = 0 or 2*pi.
       a_axis.set_value(0,0,1);
       a_radians = 0;
       return false;
@@ -183,10 +185,10 @@ public:
     return true;
   }
 
-/*
   template <class MAT4>
   void set_value(const MAT4& a_m,T(*a_sqrt)(T)) {
-    //WARNING : not tested.
+    // See tests/qrot.icc.
+    // code taken from coin3d/SbRotation.
 
     //Set the rotation from the components of the given matrix.
 
@@ -196,9 +198,9 @@ public:
       m_quat.v3(_s * half());
       _s = half() / _s;
 
-      m_quat.v0((a_m.v12() - a_m.v21()) * _s);
-      m_quat.v1((a_m.v20() - a_m.v02()) * _s);
-      m_quat.v2((a_m.v01() - a_m.v10()) * _s);
+      m_quat.v0((a_m.v21() - a_m.v12()) * _s);
+      m_quat.v1((a_m.v02() - a_m.v20()) * _s);
+      m_quat.v2((a_m.v10() - a_m.v01()) * _s);
     } else {
       unsigned int i = 0;
       if (a_m.v11() > a_m.v00()) i = 1;
@@ -212,26 +214,27 @@ public:
       m_quat.set_value(i,_s * half());
       _s = half() / _s;
   
-      m_quat.v3((a_m.value(j,k) - a_m.value(k,j)) * _s);
-      m_quat.set_value(j,(a_m.value(i,j) + a_m.value(j,i)) * _s);
-      m_quat.set_value(k,(a_m.value(i,k) + a_m.value(k,i)) * _s);
+      m_quat.v3((a_m.value(k,j) - a_m.value(j,k)) * _s);
+      m_quat.set_value(j,(a_m.value(j,i) + a_m.value(i,j)) * _s);
+      m_quat.set_value(k,(a_m.value(k,i) + a_m.value(i,k)) * _s);
     }
 
     if (a_m.v33()!=one()) {
       m_quat.multiply(one()/a_sqrt(a_m.v33()));
     }
   }
-*/
 
   template <class MAT4>
   void value(MAT4& a_m) const {
     //Return this rotation in the form of a matrix.
+    //NOTE : in coin3d/SbRotation, it looks as if "w <-> -w", but coin3d/SbMatrix logic is transposed relative to us.
+    
     const T x = m_quat.v0();
     const T y = m_quat.v1();
     const T z = m_quat.v2();
     const T w = m_quat.v3();
-    // z = w + x * i + y * j + z * k
-  
+    // q = w + x * i + y * j + z * k
+
     // first row :
     a_m.v00(w*w + x*x - y*y - z*z);
     a_m.v01(2*x*y - 2*w*z);

source/analysis/g4tools/include/tools/lina/rotf

@@ -45,11 +45,12 @@ public:
   bool set_value(const vec3f& a_from,float a_a){
     return parent::set_value(a_from,a_a,::sinf,::cosf);
   }
-  bool value(vec3f& a_from,float a_a) const {
+  bool value(vec3f& a_from,float& a_a) const {
     return parent::value(a_from,a_a,::sinf,::acosf); //WARNING acos and not cos
   }
-  //void set_value(const mat4f& a_m) {parent::set_value(a_m,::sqrtf);}
+
   void value(mat4f& a_m) const {parent::value(a_m);}
+  void set_value(const mat4f& a_m) {parent::set_value(a_m,::sqrtf);}
 
   //NOTE : don't handle a static object because of mem balance.
   //static const rotf& identity() {

source/analysis/g4tools/include/tools/lina/vec3

@@ -196,16 +196,16 @@ public:
     m_data[2] -= a2;
   }    
 
-/*
-  bool cos_angle(const vec3& a_v,T& a_cos) const {
+  bool cos_angle(const vec3& a_v,T& a_cos,T(*a_sqrt)(T)) const {
     //WARNING : if ret false, a_cos is not set.
-    if(length()==T()) return false;
-    if(a_v.length()==T()) return false;
-    a_cos = dot(a_v)/(length()*a_v.length());
+    T this_length = length(a_sqrt);
+    if(this_length==T()) return false;
+    T a_v_length = a_v.length(a_sqrt);
+    if(a_v_length==T()) return false;
+    a_cos = dot(a_v)/(this_length*a_v_length);
     return true;
   }
 
-*/
   bool theta_phi(T& a_theta,T& a_phi,T(*a_sqrt)(T),T(*a_atan2)(T,T)) const {    
     //WARNING : if ret false, a_theta, a_phi are not set.
     if(length(a_sqrt)==T()) return false;

source/analysis/g4tools/include/tools/lina/vec3d

@@ -68,6 +68,35 @@ public: //operators
 public:
   double length() const {return parent::length(::sqrt);}
   double normalize() {return parent::normalize(::sqrt);}
+public: //for g4dum/G4ThreeVector :
+  double mag2() const {return m_data[0]*m_data[0]+m_data[1]*m_data[1]+m_data[2]*m_data[2];}
+  void set(double a_0,double a_1,double a_2) {
+    m_data[0] = a_0;
+    m_data[1] = a_1;
+    m_data[2] = a_2;
+  }
+  void rotateUz(const vec3d& a_new_uz_vector) { //from CLHEP/ThreeVector.cc.
+    // a_new_uz_vector must be normalized !
+    double& dx = m_data[0];
+    double& dy = m_data[1];
+    double& dz = m_data[2];
+    double u1 = a_new_uz_vector.x();
+    double u2 = a_new_uz_vector.y();
+    double u3 = a_new_uz_vector.z();
+    double up = u1*u1 + u2*u2;
+    if (up>0) {
+      up = std::sqrt(up);
+      double px = dx,  py = dy,  pz = dz;
+      dx = (u1*u3*px - u2*py)/up + u1*pz;
+      dy = (u2*u3*px + u1*py)/up + u2*pz;
+      dz =    -up*px +             u3*pz;
+    } else if (u3 < 0.) { // phi=0  teta=pi
+      dx = -dx; dz = -dz;
+    } else {
+    }
+    //return *this;
+  }
+
 
 private:static void check_instantiation() {vec3d v(0,0,0);v.set_value(1,1,1);}
 };

source/analysis/g4tools/include/tools/lina/vec3f

@@ -77,9 +77,19 @@ public:
     divide(norme);
     return norme;
   }
+  bool cos_angle(const vec3f& a_v,float& a_cos) const {
+    //WARNING : if ret false, a_cos is not set.
+    float this_length = length();
+    if(this_length==0.0f) return false;
+    float a_v_length = a_v.length();
+    if(a_v_length==0.0f) return false;
+    a_cos = dot(a_v)/(this_length*a_v_length);
+    return true;
+  }
 #else
   float length() const {return parent::length(::sqrtf);}
   float normalize() {return parent::normalize(::sqrtf);}
+  bool cos_angle(const vec3f& a_v,float& a_cos) const {return parent::cos_angle(a_v,a_cos,::sqrtf);}
 #endif
 
   bool theta_phi(float& a_theta,float& a_phi) const {

source/analysis/g4tools/include/tools/lina/vec4

@@ -92,9 +92,10 @@ public:
   void v2(const T& a_value) { m_data[2] = a_value;}
   void v3(const T& a_value) { m_data[3] = a_value;}
 
-  //T x() const {return m_data[0];}
-  //T y() const {return m_data[1];}
-  //T z() const {return m_data[2];}
+  const T& x() const { return m_data[0];}
+  const T& y() const { return m_data[1];}
+  const T& z() const { return m_data[2];}
+  const T& t() const { return m_data[3];}
 
   void set_value(const T& a0,const T& a1,const T& a2,const T& a3) {
     m_data[0] = a0;