Import Geant4 10.2.0 source tree

2016-06-10 14:11:04 +02:00
parent c9b32a6c0a
commit d4af681f38
4886 changed files with 420149 additions and 1023309 deletions
@@ -0,0 +1,161 @@
+// Copyright (C) 2010, Guy Barrand. All rights reserved.
+// See the file tools.license for terms.
+
+#ifndef tools_axis
+#define tools_axis
+
+#include "mathf"
+ 
+namespace tools {
+
+class axis {
+public:
+  axis()
+  :m_min_value(0)
+  ,m_max_value(0)
+  ,m_steps(0)
+  ,m_is_log(false)
+  {}
+  virtual ~axis(){}
+public:
+  axis(const axis& a_from)
+  :m_min_value(a_from.m_min_value)
+  ,m_max_value(a_from.m_max_value)
+  ,m_steps(a_from.m_steps)
+  ,m_is_log(a_from.m_is_log)
+  {}
+  axis& operator=(const axis& a_from){
+    m_min_value = a_from.m_min_value;
+    m_max_value = a_from.m_max_value;
+    m_steps = a_from.m_steps;
+    m_is_log = a_from.m_is_log;
+    return *this;
+  }
+public:
+  bool is_log(bool a_v){
+    if(m_is_log==a_v) return false; 
+    m_is_log = a_v;
+    return true;
+  }
+  bool min_value(float a_v) {
+    if(m_min_value==a_v) return false; 
+    m_min_value = a_v;
+    return true;
+  }
+  bool max_value(float a_v) {
+    if(m_max_value==a_v) return false; 
+    m_max_value = a_v;
+    return true;
+  }
+  float min_value() const {return m_min_value;}
+  float max_value() const {return m_max_value;}
+  bool is_log() const {return m_is_log;}
+
+  void adjust_axis() { //from hippodraw.
+    int _axis = 0;
+    float step;
+    float mylow, myhigh;
+    int N_NICE = 4;
+    static const float nice[/*N_NICE*/4] = { 1.0,2.0,2.5,5.0 };
+  
+    if (m_min_value > m_max_value) {
+      float low = m_min_value;
+      m_min_value = m_max_value;
+      m_max_value = low;  
+    } else if (m_min_value == m_max_value) {
+      float value = m_min_value;  
+      m_min_value = value - 1;
+      m_max_value = value + 1;
+      return;
+    }
+  
+    if (m_steps <= 0) {
+      _axis    = 1;
+      m_steps = 10;
+    }
+
+    // Round the "bin width" to a nice number.
+    // If this is being done for an axis (ie m_steps was 0 , then
+    // we don't have to go > *m_max_value.
+    //
+    float w = (m_max_value - m_min_value)/((float)m_steps);
+    float mag = ffloor(flog10(w));  
+    int i = 0;
+    do {
+      step   = nice[i] * fpow(10.0,mag);
+    
+      mylow  = ffloor(m_min_value/step) * step;
+      myhigh = _axis==1 ? fceil(m_max_value/step) * step : 
+                         mylow + step * m_steps;
+    
+      i++;
+      if (i>=N_NICE) {
+        i = 0;
+        mag++;
+      }
+    }
+    while ( ( (_axis==1) && myhigh < m_max_value) || 
+            ( (_axis==0) && myhigh <= m_max_value) );
+  
+    float range = myhigh - mylow;
+  
+    // we now have decided on a range. Try to move 
+    // m_min_value/m_max_value a little
+    // to end up on a nice number.
+    //
+    // first check if either end is near 0.0
+    if ( !m_is_log && (m_min_value >= 0.0) && 
+        (( (_axis==1) && (range>=m_max_value) ) || 
+         ( (_axis==0) && (range>m_max_value) )) ) {  
+      m_min_value = 0.0;
+      m_max_value = range;
+      return;
+    }
+  
+    if ( (( (_axis==1) && (m_max_value<=0.0) ) || 
+          ( (_axis==0) && (m_max_value<0.0) )) 
+         && (-range<=m_min_value)) {     
+      m_max_value = 0.0;
+      m_min_value = -range;
+      return;
+    }
+ 
+    // try to round *m_min_value.
+    // correction
+    if( m_is_log && (m_min_value<=0.0)) {  
+      m_min_value = 1.0;
+    }
+    
+    i   = N_NICE-1;
+    mag = myhigh != 0.0 ? fceil(flog10(ffabs(myhigh))) : 
+                          fceil(flog10(ffabs(mylow)));
+    
+    do {
+      step   = nice[i] * fpow(10.0,mag);        
+      mylow  = ffloor(m_min_value/step) * step;
+      myhigh = mylow + range;      
+      i--;
+      if (i<0) {
+        i = N_NICE-1;
+        mag--;
+      }
+    } 
+    while (( m_is_log && (mylow  <= 0.0)     ) || 
+           ( (_axis==1)  && (myhigh < m_max_value)  ) || 
+           ( (_axis==0)  && (myhigh <= m_max_value) ) );
+    
+    m_min_value = mylow;
+    m_max_value = myhigh;    
+  }
+
+
+protected:
+  float m_min_value;
+  float m_max_value;
+  int m_steps;
+  bool m_is_log;
+};
+
+}
+
+#endif