updated the ChangeLog.

CMakeLists.txt

@@ -5,30 +5,31 @@ if (CMAKE_VERSION GREATER_EQUAL 3.12)
   cmake_policy(SET CMP0075 NEW)
 endif (CMAKE_VERSION GREATER_EQUAL 3.12)
 
-project(musrfit VERSION 1.7.1 LANGUAGES C CXX)
+project(musrfit VERSION 1.7.4 LANGUAGES C CXX)
 
 #--- musrfit specific options -------------------------------------------------
 option(nexus "build optional NeXus support. Needed for ISIS" OFF)
 option(ASlibs "build optional ASlibs" OFF)
 option(BMWlibs "build optional BMWlibs" OFF)
 option(BNMRlibs "build optional beta-NMR libs" OFF)
+option(DummyUserFcn "build optional dummy user function" OFF)
 option(qt_based_tools "try to install Qt based tools (musredit, musrWiz, musrStep, mupp)" ON)
 option(try_OpenMP "try to use OpenMP if available" ON)
-# define qt_version with possible values 'auto' or version '3', '4', '5'
+# define qt_version with possible values 'auto' or version '3', '4', '5', '6'
 set(qt_version AUTO CACHE STRING "provide a specific Qt version to be used.")
-set_property(CACHE qt_version PROPERTY STRINGS AUTO 3 4 5)
+set_property(CACHE qt_version PROPERTY STRINGS AUTO 3 4 5 6)
 
 #--- set a default build type if none was specified ---------------------------
 set(default_build_type "Release")
- 
+  
-if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
   set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE
       STRING "Choose the type of build." FORCE)
   # Set the possible values of build type for cmake-gui
   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
     "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
-endif()
+endif ()
 
 #--- perform some checks and generate the config.h ----------------------------
 
@@ -311,6 +312,9 @@ if (BNMRlibs)
 else (BNMRlibs)
   message("   BNMRlibs                           : no")
 endif (BNMRlibs)
+if (DummyUserFcn)
+  message("   PDummyUserFcn                      : yes")
+endif (DummyUserFcn)
 
 if (qt_based_tools)
 if (Qt6Core_FOUND)

ChangeLog

@@ -12,7 +12,30 @@ or
 
 https://bitbucket.org/muonspin/musrfit/commits/all
 
-Release of V1.7.0, 2021/03/30
+Release of V1.7.4, 2021/06/16
+=============================
+
+allow in asymmetry fits #forward groups != #backward groups
+
+Release of V1.7.3, 2021/06/01
+=============================
+
+making musrfit Apple Silicon M1 ready. Currently there is still an open issue 
+with NeXus (HDF4 only).
+
+Release of V1.7.2, 2021/04/16
+=============================
+
+add a full dummy user function class with a global part. This can be used as 
+a starting point to develop new polarization functions. 
+Currently no rge-handling present.
+
+Release of V1.7.1, 2021/04/09
+=============================
+
+update of the docu. More version info. Dealing with the upcoming ROOT V6.24.
+
+Release of V1.7.0, 2021/04/30
 =============================
 
 Centralize the rge-handling for user functions.

cmake/config.h.in

@@ -2,6 +2,7 @@
 
 #define PACKAGE_VERSION "@PROJECT_VERSION@"
 #define ROOT_VERSION_USED "@ROOT_VERSION@"
+#define BUILD_TYPE "@CMAKE_BUILD_TYPE@"
 
 // define to 1 if minor ROOT6 version is >= 24
 #define ROOT_GRTEQ_24 @ROOT_GRTEQ_24@

doc/examples/UserFcnWithGlobal/README

@@ -0,0 +1,18 @@
+/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
+
+Simple Example for a User Function *with* a Global Part
+
+/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
+
+The source code is found under 
+
+<musrfit-dir>src/external/DummyUserFcn
+
+For details see there.
+
+This dummy user function implements an exp(-lambda*t)
+in the global part. This is the most efficient way, 
+since the function time vector is only calculated once
+when the parameter (lambda) changes. For all the 
+subsequent calls a lookup table is used to return the
+value of the user function.

doc/examples/UserFcnWithGlobal/test-histo-PSI-BIN-UserFcn.msr

@@ -0,0 +1,73 @@
+FeSe 9p4 TF100 p107apr09_sample*1p02                          
+###############################################################
+FITPARAMETER
+#      Nr. Name       Value     Step      Pos_Error Boundaries   
+        1 Asy         0.2622    -0.0014     0.0014      0       0.33    
+        2 Rate        0.3188    -0.0044     0.0044      
+        3 Field       97.853    -0.056      0.056       0       200     
+        4 Phase_L     178.95    -0.41       0.41        
+        5 Phase_R     1.75      -0.39       0.39        
+        6 N0_L        1097.9    -1.0        1.0         
+        7 N0_R        1159.7    -1.0        1.0         
+        8 Bkg_L       54.47     -0.20       0.20        
+        9 Bkg_R       46.70     -0.19       0.19        
+
+###############################################################
+THEORY
+asymmetry      1
+userFcn libPDummyUserFcn   PDummyUserFcn    2          (rate)
+TFieldCos   map1  fun1       (phase frequency)
+
+###############################################################
+FUNCTIONS
+fun1 = par3 * gamma_mu
+
+###############################################################
+GLOBAL
+fittype         0         (single histogram fit)
+fit             0       8.2    
+packing         1
+
+###############################################################
+RUN ../data/deltat_pta_gpd_0423 PIE1 PSI PSI-BIN   (name beamline institute data-file-format)
+norm            6
+backgr.fit      8
+map             4    0    0    0    0    0    0    0    0    0
+forward         1 
+data            165     7965    
+t0              162.0   
+
+RUN ../data/deltat_pta_gpd_0423 PIE1 PSI PSI-BIN   (name beamline institute data-file-format)
+norm            7
+backgr.fit      9
+map             5    0    0    0    0    0    0    0    0    0
+forward         2 
+data            205     7965    
+t0              202.0   
+
+###############################################################
+COMMANDS
+SCALE_N0_BKG TRUE
+MINIMIZE
+MINOS
+SAVE
+
+###############################################################
+PLOT 0   (single histo plot)
+lifetimecorrection
+runs     1  2
+range    0.0  9.5  -0.3 0.3
+view_packing 25
+
+###############################################################
+FOURIER
+units            Gauss   # units either 'Gauss', 'Tesla', 'MHz', or 'Mc/s'
+fourier_power    12
+apodization      NONE    # NONE, WEAK, MEDIUM, STRONG
+plot             REAL    # REAL, IMAG, REAL_AND_IMAG, POWER, PHASE
+phase            par4 par5
+range            0.0    200.0
+
+###############################################################
+STATISTIC --- 2015-01-05 14:09:47
+  chisq = 663.9, NDF = 515, chisq/NDF = 1.289169

src/any2many.cpp

@@ -197,7 +197,7 @@ int main(int argc, char *argv[])
       any2many_syntax();
     else if (strstr(argv[1], "--v")) {
 #ifdef HAVE_CONFIG_H
-      std::cout << std::endl << "any2many version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << ", ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
+      std::cout << std::endl << "any2many version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
 #else
       std::cout << std::endl << "any2many git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
 #endif

src/classes/PMsrHandler.cpp

@@ -6334,16 +6334,7 @@ Bool_t PMsrHandler::CheckHistoGrouping()
 {
   Bool_t result = true;
 
-  for (UInt_t i=0; i<fRuns.size(); i++) {
+  for (UInt_t i=0; i<fRuns.size(); i++) {    
-    if (fRuns[i].GetFitType() == MSR_FITTYPE_ASYM || fRuns[i].GetFitType() == MSR_FITTYPE_BNMR) {
-      if (fRuns[i].GetForwardHistoNoSize() != fRuns[i].GetBackwardHistoNoSize()) {
-        std::cerr << std::endl << ">> PMsrHandler::CheckHistoGrouping: **ERROR** # of forward histos != # of backward histos.";
-        std::cerr << std::endl << ">> Run #" << i+1;
-        std::cerr << std::endl;
-        result = false;
-        break;
-      }
-    }
     // check grouping entries are not identical, e.g. forward 1 1 2
     if (fRuns[i].GetForwardHistoNoSize() > 1) {
       for (UInt_t j=0; j<fRuns[i].GetForwardHistoNoSize(); j++) {
@@ -6668,13 +6659,18 @@ void PMsrHandler::MakeDetectorGroupingString(TString str, PIntVector &group, TSt
     str = "";
   }
 
+  if (group.size()==0)
+    return;
+
   UInt_t i=0, j=0;
   do {
     j = i;
-    while (group[j]+1 == group[j+1]) {
+    if (j+1 < group.size()) {
-      j++;
+      while (group[j]+1 == group[j+1]) {
-      if (j == group.size()-1)
+        j++;
-        break;
+        if (j == group.size()-1)
+          break;
+      }
     }
 
     if (j >= i+2) {

src/classes/PRunAsymmetry.cpp

@@ -602,17 +602,7 @@ Bool_t PRunAsymmetry::PrepareData()
       return false;
     }
   }
-  if (forwardHistoNo.size() != backwardHistoNo.size()) {
+  
-    std::cerr << std::endl << ">> PRunAsymmetry::PrepareData(): **PANIC ERROR**:";
-    std::cerr << std::endl << ">> # of forward histograms different from # of backward histograms.";
-    std::cerr << std::endl << ">> Will quit :-(";
-    std::cerr << std::endl;
-    // clean up
-    forwardHistoNo.clear();
-    backwardHistoNo.clear();
-    return false;
-  }
-
   // keep the time resolution in (us)
   fTimeResolution = runData->GetTimeResolution()/1.0e3;
   std::cout.precision(10);
@@ -626,11 +616,13 @@ Bool_t PRunAsymmetry::PrepareData()
   // keep the histo of each group at this point (addruns handled below)
   std::vector<PDoubleVector> forward, backward;
   forward.resize(forwardHistoNo.size());   // resize to number of groups
-  backward.resize(backwardHistoNo.size()); // resize to numer of groups
   for (UInt_t i=0; i<forwardHistoNo.size(); i++) {
     forward[i].resize(runData->GetDataBin(forwardHistoNo[i])->size());
-    backward[i].resize(runData->GetDataBin(backwardHistoNo[i])->size());
     forward[i]  = *runData->GetDataBin(forwardHistoNo[i]);
+  }
+  backward.resize(backwardHistoNo.size()); // resize to number of groups
+  for (UInt_t i=0; i<backwardHistoNo.size(); i++) {
+    backward[i].resize(runData->GetDataBin(backwardHistoNo[i])->size());
     backward[i] = *runData->GetDataBin(backwardHistoNo[i]);
   }
 
@@ -676,9 +668,11 @@ Bool_t PRunAsymmetry::PrepareData()
 
   // set forward/backward histo data of the first group
   fForward.resize(forward[0].size());
-  fBackward.resize(backward[0].size());
   for (UInt_t i=0; i<fForward.size(); i++) {
     fForward[i]  = forward[0][i];
+  }
+  fBackward.resize(backward[0].size());
+  for (UInt_t i=0; i<fBackward.size(); i++) {
     fBackward[i] = backward[0][i];
   }
 
@@ -781,7 +775,21 @@ Bool_t PRunAsymmetry::PrepareData()
  */
 Bool_t PRunAsymmetry::SubtractFixBkg()
 {
+  if (fRunInfo->GetBkgFix(0) == PMUSR_UNDEFINED) {
+    std::cerr << "PRunAsymmetry::SubtractFixBkg(): **ERROR** no fixed bkg for forward set. Will do nothing here." << std::endl;
+    return false;
+  }
+  if (fRunInfo->GetBkgFix(1) == PMUSR_UNDEFINED) {
+    std::cerr << "PRunAsymmetry::SubtractFixBkg(): **ERROR** no fixed bkg for backward set. Will do nothing here." << std::endl;
+    std::cerr << "   you need an entry like:" << std::endl;
+    std::cerr << "   backgr.fix      2  3" << std::endl;
+    std::cerr << "   i.e. two entries for forward and backward." << std::endl;
+    return false;
+  }
+
+
   Double_t dval;
+
   for (UInt_t i=0; i<fForward.size(); i++) {
     // keep the error, and make sure that the bin is NOT empty
     if (fForward[i] != 0.0)
@@ -1005,8 +1013,8 @@ Bool_t PRunAsymmetry::PrepareFitData()
   Double_t asym;
   Double_t f, b, ef, eb;
   // fill data time start, and step
-  // data start at data_start-t0 shifted by (pack-1)/2
+  // data start time = (binStart - 0.5) + pack/2 - t0, with pack and binStart used as double
-  fData.SetDataTimeStart(fTimeResolution*(static_cast<Double_t>(fGoodBins[0])-fT0s[0]+static_cast<Double_t>(fPacking-1)/2.0));
+  fData.SetDataTimeStart(fTimeResolution*((static_cast<Double_t>(fGoodBins[0])-0.5) + static_cast<Double_t>(fPacking)/2.0 - static_cast<Double_t>(fT0s[0])));
   fData.SetDataTimeStep(fTimeResolution*static_cast<Double_t>(fPacking));
   for (UInt_t i=0; i<noOfBins; i++) {
     // to make the formulae more readable
@@ -1207,8 +1215,8 @@ Bool_t PRunAsymmetry::PrepareViewData(PRawRunData* runData, UInt_t histoNo[2])
   Double_t asym;
   Double_t f, b, ef, eb, alpha = 1.0, beta = 1.0;
   // set data time start, and step
-  // data start at data_start-t0
+  // data start time = (binStart - 0.5) + pack/2 - t0, with pack and binStart used as double
-  fData.SetDataTimeStart(fTimeResolution*(static_cast<Double_t>(start[0])-t0[0]+static_cast<Double_t>(packing-1)/2.0));
+  fData.SetDataTimeStart(fTimeResolution*((static_cast<Double_t>(start[0])-0.5) + static_cast<Double_t>(packing)/2.0 - static_cast<Double_t>(t0[0])));
   fData.SetDataTimeStep(fTimeResolution*static_cast<Double_t>(packing));
 
   // get the proper alpha and beta
@@ -1586,8 +1594,8 @@ Bool_t PRunAsymmetry::PrepareRRFViewData(PRawRunData* runData, UInt_t histoNo[2]
   }
 
   // set data time start, and step
-  // data start at data_start-t0
+  // data start time = (binStart - 0.5) + pack/2 - t0, with pack and binStart used as double
-  fData.SetDataTimeStart(fTimeResolution*(start[0]-t0[0]+static_cast<Double_t>(packing-1)/2.0));
+  fData.SetDataTimeStart(fTimeResolution*((static_cast<Double_t>(start[0])-0.5) + static_cast<Double_t>(packing)/2.0 - static_cast<Double_t>(t0[0])));
   fData.SetDataTimeStep(fTimeResolution*static_cast<Double_t>(packing));
 
   // ------------------------------------------------------------
@@ -1663,7 +1671,7 @@ Bool_t PRunAsymmetry::PrepareRRFViewData(PRawRunData* runData, UInt_t histoNo[2]
 //--------------------------------------------------------------------------
 /**
  * <p>Get the proper t0 for the single histogram run.
- * -# the t0 vector size = number of detectors (grouping) for forward.
+ * -# the t0 vector size = number of detectors (grouping) for forward + backward.
  * -# initialize t0's with -1
  * -# fill t0's from RUN block
  * -# if t0's are missing (i.e. t0 == -1), try to fill from the GLOBAL block.
@@ -1684,7 +1692,11 @@ Bool_t PRunAsymmetry::GetProperT0(PRawRunData* runData, PMsrGlobalBlock *globalB
   // feed all T0's
   // first init T0's, T0's are stored as (forward T0, backward T0, etc.)
   fT0s.clear();
-  fT0s.resize(2*forwardHistoNo.size());
+  // this strange fT0 size estimate is needed in case #forw histos != #back histos
+  size_t size = 2*forwardHistoNo.size();
+  if (backwardHistoNo.size() > forwardHistoNo.size())
+    size = 2*backwardHistoNo.size();
+  fT0s.resize(size);
   for (UInt_t i=0; i<fT0s.size(); i++) {
     fT0s[i] = -1.0;
   }
@@ -1751,6 +1763,8 @@ Bool_t PRunAsymmetry::GetProperT0(PRawRunData* runData, PMsrGlobalBlock *globalB
       std::cerr << std::endl;
       return false;
     }
+  }
+  for (UInt_t i=0; i<backwardHistoNo.size(); i++) {
     if ((fT0s[2*i+1] < 0) || (fT0s[2*i+1] > static_cast<Int_t>(runData->GetDataBin(backwardHistoNo[i])->size()))) {
       std::cerr << std::endl << ">> PRunAsymmetry::PrepareData(): **ERROR** t0 data bin (" << fT0s[2*i+1] << ") doesn't make any sense!";
       std::cerr << std::endl << ">> backwardHistoNo " << backwardHistoNo[i];

src/classes/PRunAsymmetryBNMR.cpp

@@ -640,6 +640,7 @@ Bool_t PRunAsymmetryBNMR::PrepareData()
       return false;
     }
   }
+/* //as35
   if (forwardHistoNo.size() != backwardHistoNo.size()) {
     std::cerr << std::endl << ">> PRunAsymmetryBNMR::PrepareData(): **PANIC ERROR**:";
     std::cerr << std::endl << ">> # of forward histograms different from # of backward histograms.";
@@ -650,7 +651,8 @@ Bool_t PRunAsymmetryBNMR::PrepareData()
     backwardHistoNo.clear();
     return false;
   }
-
+*/ //as35
+  
   // keep the time resolution in (s)
   fTimeResolution = runData->GetTimeResolution()/1.0e3;
   std::cout.precision(10);
@@ -664,11 +666,13 @@ Bool_t PRunAsymmetryBNMR::PrepareData()
   // keep the histo of each group at this point (addruns handled below)
   std::vector<PDoubleVector> forward, backward;
   forward.resize(forwardHistoNo.size());   // resize to number of groups
-  backward.resize(backwardHistoNo.size()); // resize to numer of groups
   for (UInt_t i=0; i<forwardHistoNo.size(); i++) {
     forward[i].resize(runData->GetDataBin(forwardHistoNo[i])->size());
-    backward[i].resize(runData->GetDataBin(backwardHistoNo[i])->size());
     forward[i]  = *runData->GetDataBin(forwardHistoNo[i]);
+  }
+  backward.resize(backwardHistoNo.size()); // resize to number of groups
+  for (UInt_t i=0; i<backwardHistoNo.size(); i++) {
+    backward[i].resize(runData->GetDataBin(backwardHistoNo[i])->size());
     backward[i] = *runData->GetDataBin(backwardHistoNo[i]);
   }
 
@@ -712,15 +716,18 @@ Bool_t PRunAsymmetryBNMR::PrepareData()
     }
   }
 
-  // set forward/backward histo data of the first group
+  // set forward histo data of the first group
   fForwardp.resize(forward[0].size());
-  fBackwardp.resize(backward[0].size());
   fForwardm.resize(forward[0].size());
-  fBackwardm.resize(backward[0].size());
   for (UInt_t i=0; i<fForwardp.size(); i++) {
     fForwardp[i]  = forward[0][i];
-    fBackwardp[i] = backward[0][i];
     fForwardm[i]  = forward[1][i];
+  }
+  // set backward histo data of the first group
+  fBackwardp.resize(backward[0].size());
+  fBackwardm.resize(backward[0].size());
+  for (UInt_t i=0; i<fBackwardp.size(); i++) {
+    fBackwardp[i] = backward[0][i];
     fBackwardm[i] = backward[1][i];
   }
 
@@ -1529,7 +1536,11 @@ Bool_t PRunAsymmetryBNMR::GetProperT0(PRawRunData* runData, PMsrGlobalBlock *glo
   // feed all T0's
   // first init T0's, T0's are stored as (forward T0, backward T0, etc.)
   fT0s.clear();
-  fT0s.resize(2*forwardHistoNo.size());
+  // this strange fT0 size estimate is needed in case #forw histos != #back histos
+  size_t size = 2*forwardHistoNo.size();
+  if (backwardHistoNo.size() > forwardHistoNo.size())
+    size = 2*backwardHistoNo.size();
+  fT0s.resize(size);
   for (UInt_t i=0; i<fT0s.size(); i++) {
     fT0s[i] = -1.0;
   }
@@ -1596,6 +1607,8 @@ Bool_t PRunAsymmetryBNMR::GetProperT0(PRawRunData* runData, PMsrGlobalBlock *glo
       std::cerr << std::endl;
       return false;
     }
+  }
+  for (UInt_t i=0; i<backwardHistoNo.size(); i++) {
     if ((fT0s[2*i+1] < 0) || (fT0s[2*i+1] > static_cast<Int_t>(runData->GetDataBin(backwardHistoNo[i])->size()))) {
       std::cerr << std::endl << ">> PRunAsymmetryBNMR::PrepareData(): **ERROR** t0 data bin (" << fT0s[2*i+1] << ") doesn't make any sense!";
       std::cerr << std::endl << ">> backwardHistoNo " << backwardHistoNo[i];

src/classes/PRunAsymmetryRRF.cpp

@@ -584,16 +584,6 @@ Bool_t PRunAsymmetryRRF::PrepareData()
       return false;
     }
   }
-  if (forwardHistoNo.size() != backwardHistoNo.size()) {
-    std::cerr << std::endl << ">> PRunAsymmetryRRF::PrepareData(): **PANIC ERROR**:";
-    std::cerr << std::endl << ">> # of forward histograms different from # of backward histograms.";
-    std::cerr << std::endl << ">> Will quit :-(";
-    std::cerr << std::endl;
-    // clean up
-    forwardHistoNo.clear();
-    backwardHistoNo.clear();
-    return false;
-  }
 
   // keep the time resolution in (us)
   fTimeResolution = runData->GetTimeResolution()/1.0e3;
@@ -608,11 +598,13 @@ Bool_t PRunAsymmetryRRF::PrepareData()
   // keep the histo of each group at this point (addruns handled below)
   std::vector<PDoubleVector> forward, backward;
   forward.resize(forwardHistoNo.size());   // resize to number of groups
-  backward.resize(backwardHistoNo.size()); // resize to numer of groups
   for (UInt_t i=0; i<forwardHistoNo.size(); i++) {
     forward[i].resize(runData->GetDataBin(forwardHistoNo[i])->size());
-    backward[i].resize(runData->GetDataBin(backwardHistoNo[i])->size());
     forward[i]  = *runData->GetDataBin(forwardHistoNo[i]);
+  }
+  backward.resize(backwardHistoNo.size()); // resize to number of groups
+  for (UInt_t i=0; i<backwardHistoNo.size(); i++) {
+    backward[i].resize(runData->GetDataBin(backwardHistoNo[i])->size());
     backward[i] = *runData->GetDataBin(backwardHistoNo[i]);
   }
 
@@ -1281,7 +1273,11 @@ Bool_t PRunAsymmetryRRF::GetProperT0(PRawRunData* runData, PMsrGlobalBlock *glob
   // feed all T0's
   // first init T0's, T0's are stored as (forward T0, backward T0, etc.)
   fT0s.clear();
-  fT0s.resize(2*forwardHistoNo.size());
+  // this strange fT0 size estimate is needed in case #forw histos != #back histos
+  size_t size = 2*forwardHistoNo.size();
+  if (backwardHistoNo.size() > forwardHistoNo.size())
+    size = 2*backwardHistoNo.size();
+  fT0s.resize(size);
   for (UInt_t i=0; i<fT0s.size(); i++) {
     fT0s[i] = -1.0;
   }
@@ -1348,6 +1344,8 @@ Bool_t PRunAsymmetryRRF::GetProperT0(PRawRunData* runData, PMsrGlobalBlock *glob
       std::cerr << std::endl;
       return false;
     }
+  }
+  for (UInt_t i=0; i<backwardHistoNo.size(); i++) {
     if ((fT0s[2*i+1] < 0) || (fT0s[2*i+1] > static_cast<Int_t>(runData->GetDataBin(backwardHistoNo[i])->size()))) {
       std::cerr << std::endl << ">> PRunAsymmetryRRF::PrepareData(): **ERROR** t0 data bin (" << fT0s[2*i+1] << ") doesn't make any sense!";
       std::cerr << std::endl << ">> backwardHistoNo " << backwardHistoNo[i];

src/classes/PRunMuMinus.cpp

@@ -604,8 +604,8 @@ Bool_t PRunMuMinus::PrepareFitData(PRawRunData* runData, const UInt_t histoNo)
   Int_t t0 = static_cast<Int_t>(fT0s[0]);
   Double_t value = 0.0;
   // data start at data_start-t0
-  // time shifted so that packing is included correctly, i.e. t0 == t0 after packing
+  // data start time = (binStart - 0.5) + pack/2 - t0, with pack and binStart used as double
-  fData.SetDataTimeStart(fTimeResolution*(static_cast<Double_t>(fGoodBins[0])-static_cast<Double_t>(t0)+static_cast<Double_t>(fPacking-1)/2.0));
+  fData.SetDataTimeStart(fTimeResolution*((static_cast<Double_t>(fGoodBins[0])-0.5) + static_cast<Double_t>(fPacking)/2.0 - static_cast<Double_t>(t0)));
   fData.SetDataTimeStep(fTimeResolution*fPacking);
   for (Int_t i=fGoodBins[0]; i<fGoodBins[1]; i++) {
     if (fPacking == 1) {
@@ -710,9 +710,8 @@ Bool_t PRunMuMinus::PrepareRawViewData(PRawRunData* runData, const UInt_t histoN
   // everything looks fine, hence fill data set
   Int_t t0 = static_cast<Int_t>(fT0s[0]);
   Double_t value = 0.0;
-  // data start at data_start-t0
+  // data start time = (binStart - 0.5) + pack/2 - t0, with pack and binStart used as double
-  // time shifted so that packing is included correctly, i.e. t0 == t0 after packing
+  fData.SetDataTimeStart(fTimeResolution*((static_cast<Double_t>(start)-0.5) + static_cast<Double_t>(packing)/2.0 - static_cast<Double_t>(t0)));
-  fData.SetDataTimeStart(fTimeResolution*(static_cast<Double_t>(start)-static_cast<Double_t>(t0)+static_cast<Double_t>(packing-1)/2.0));
   fData.SetDataTimeStep(fTimeResolution*packing);
 
   for (Int_t i=start; i<end; i++) {

src/classes/PRunSingleHisto.cpp

@@ -888,7 +888,7 @@ Bool_t PRunSingleHisto::PrepareFitData(PRawRunData* runData, const UInt_t histoN
     normalizer = fPacking * (fTimeResolution * 1.0e3); // fTimeResolution us->ns
   // data start at data_start-t0
   // time shifted so that packing is included correctly, i.e. t0 == t0 after packing
-  fData.SetDataTimeStart(fTimeResolution*(static_cast<Double_t>(fGoodBins[0])-static_cast<Double_t>(t0)+static_cast<Double_t>(fPacking-1)/2.0));
+  fData.SetDataTimeStart(fTimeResolution*((static_cast<Double_t>(fGoodBins[0])-0.5) + static_cast<Double_t>(fPacking)/2.0 - static_cast<Double_t>(t0)));
   fData.SetDataTimeStep(fTimeResolution*fPacking);
   for (Int_t i=fGoodBins[0]; i<fGoodBins[1]; i++) {
     if (fPacking == 1) {
@@ -991,9 +991,8 @@ Bool_t PRunSingleHisto::PrepareRawViewData(PRawRunData* runData, const UInt_t hi
   // everything looks fine, hence fill data set
   Int_t t0 = static_cast<Int_t>(fT0s[0]);
   Double_t value = 0.0;
-  // data start at data_start-t0
+  // data start time = (binStart - 0.5) + pack/2 - t0, with pack and binStart used as double
-  // time shifted so that packing is included correctly, i.e. t0 == t0 after packing
+  fData.SetDataTimeStart(fTimeResolution*((static_cast<Double_t>(start)-0.5) + static_cast<Double_t>(packing)/2.0 - static_cast<Double_t>(t0)));
-  fData.SetDataTimeStart(fTimeResolution*(static_cast<Double_t>(start)-static_cast<Double_t>(t0)+static_cast<Double_t>(packing-1)/2.0));
   fData.SetDataTimeStep(fTimeResolution*packing);
 
   for (Int_t i=start; i<end; i++) {
@@ -1247,8 +1246,8 @@ Bool_t PRunSingleHisto::PrepareViewData(PRawRunData* runData, const UInt_t histo
   Double_t rrf_val = 0.0;
   Double_t time = 0.0;
 
-  // data start at data_start-t0 shifted by (pack-1)/2
+  // data start time = (binStart - 0.5) + pack/2 - t0, with pack and binStart used as double
-  fData.SetDataTimeStart(fTimeResolution*(static_cast<Double_t>(start)-static_cast<Double_t>(t0)+static_cast<Double_t>(packing-1)/2.0));
+  fData.SetDataTimeStart(fTimeResolution*((static_cast<Double_t>(start)-0.5) + static_cast<Double_t>(packing)/2.0 - static_cast<Double_t>(t0)));
   fData.SetDataTimeStep(fTimeResolution*packing);
 
   // data is always normalized to (per nsec!!)
@@ -1257,7 +1256,8 @@ Bool_t PRunSingleHisto::PrepareViewData(PRawRunData* runData, const UInt_t histo
     for (Int_t i=start; i<end; i++) {
       if (((i-start) % packing == 0) && (i != start)) { // fill data
         value *= dataNorm;
-        time = ((static_cast<Double_t>(i)-static_cast<Double_t>(packing-1)/2.0)-t0)*fTimeResolution;
+        // since the packing counter is already at the end of the bin, the time needs be shifted back by pack*time_resolution
+        time = (((static_cast<Double_t>(i)-0.5) + static_cast<Double_t>(packing)/2.0 - static_cast<Double_t>(t0)))*fTimeResolution - static_cast<Double_t>(packing)*fTimeResolution;
         expval = TMath::Exp(+time/tau)/N0;
         fData.AppendValue(-1.0+expval*(value-bkg));
         fData.AppendErrorValue(expval*TMath::Sqrt(value*dataNorm));
@@ -1316,7 +1316,7 @@ Bool_t PRunSingleHisto::PrepareViewData(PRawRunData* runData, const UInt_t histo
   // calculate theory
   Double_t theoryValue;
   UInt_t size = fForward.size()/packing;
-  Int_t factor = 8; // 8 times more points for the theory (if fTheoAsData == false)
+  const Int_t factor = 8; // 8 times more points for the theory (if fTheoAsData == false)
   UInt_t rebinRRF = 0;
 
   if (wRRF == 0) { // no RRF

src/dump_header.cpp

@@ -447,7 +447,8 @@ int dump_header_mud(const std::string fileName, const std::string fileFormat)
   // start time
   time_t tval;
   struct tm *dt;
-  success = MUD_getTimeBegin( fh, (UINT32*)&tval );
+  success = MUD_getTimeBegin( fh, &val );
+  tval = static_cast<time_t>(val);
   if (success) {
     dt = localtime(static_cast<const time_t*>(&tval));
     assert(dt);
@@ -457,7 +458,8 @@ int dump_header_mud(const std::string fileName, const std::string fileFormat)
     std::cout << std::endl << "Run Start Time     : ???";
   }
   // stop time
-  success = MUD_getTimeEnd( fh, (UINT32*)&tval );
+  success = MUD_getTimeEnd( fh, &val );
+  tval = static_cast<time_t>(val);
   if (success) {
     dt = localtime(static_cast<const time_t*>(&tval));
     assert(dt);
@@ -776,7 +778,7 @@ int main(int argc, char *argv[])
       return 0;
     } else if (!strcmp(argv[i], "--version") || !strcmp(argv[i], "-v")) {
 #ifdef HAVE_CONFIG_H
-      std::cout << std::endl << "dump_header version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << ", ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
+      std::cout << std::endl << "dump_header version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
 #else
       std::cout << std::endl << "dump_header git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
 #endif

src/external/CMakeLists.txt

@@ -29,3 +29,7 @@ if (nexus)
   add_subdirectory(nexus)
 endif (nexus)
 
+if (DummyUserFcn)
+  add_subdirectory(DummyUserFcn)
+endif (DummyUserFcn)
+

src/external/DummyUserFcn/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(src)

src/external/DummyUserFcn/README

@@ -0,0 +1,99 @@
+/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
+
+Simple Example for a User Function *with* a Global Part
+
+/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
+
+This is a full implementation of a user function with a global part.
+For a general intro to user function, please check the manual under
+
+http://lmu.web.psi.ch/musrfit/user/html/user-manual.html#id38
+
+The implemented user function is
+
+exp(-lambda*t)
+
+with lambda, being the only parameter.
+
+Short description of the PDummyUserFcn and PDummyUserFcnGlobal classes.
+
+PDummyUserFcn:
+-------------
+
+This class derives from the PUserFcnBase which is necessary to make this
+user function available to musrfit.
+
+The three functions:
+
+    virtual Bool_t NeedGlobalPart() const { return true; }
+    virtual void SetGlobalPart(std::vector<void*> &globalPart, UInt_t idx);
+    virtual Bool_t GlobalPartIsValid() const;
+
+are used to bind the global part of the user function.
+
+The method
+
+    virtual Double_t operator()(Double_t t, const std::vector<Double_t> &param) const;
+
+is called by musrfit when evaluate the function.
+
+The private variables:
+
+    Bool_t fValid{true};
+    Bool_t fInvokedGlobal{false};
+    Int_t fIdxGlobal;
+
+    PDummyUserFcnGlobal *fDummyUserFcnGlobal{nullptr};
+
+have the following purpose:
+
+    fValid is a boolean variable holding the state of the user function. 
+           If true, it means that the user function is useable. In case
+           something would go wrong during the initialization stage fValid
+           is set to false, and no calculation will take place!
+    fInvokedGlobal is a boolean variable which is set to true is the global
+           part of the user function is properly invoked.
+    fIdxGlobal holds the index of the global user function part.
+ 
+PDummyUserFcnGlobal:
+-------------------
+
+This class holds the gloabl user function part, which handles the actual 
+calculation of the user function.
+
+    CalculatePol(const std::vector<Double_t> &param) const; -> carries out the
+          necessary calculations of this user function. This is ONLY carried 
+          out if the parameter set has changed!
+
+    GetPolValue(const Double_t t) const; -> This is used in the operator() of
+          the user function to get the value of the user function (here a 
+          value of a polarization function exp()).
+
+    mutable std::vector<Double_t> fPreviousParam; -> holds the previous 
+          parmeter set in order to check if a parameter set has changed.
+
+    mutable std::vector<Double_t> fPol; -> lookup table for the polarization
+          function for the current parameter set.
+
+How to build:
+------------
+
+When configure musrfit, there is a switch DummyUserFcn available which
+needs to be enabled (default: OFF), e.g.
+
+cmake ../ -DCMAKE_INSTALL_PREFIX=$ROOTSYS -Dnexus=1 -DDummyUserFcn=1
+
+Files:
+-----
+  CMakeLists.txt <- this File is needed to allow to build an install
+                    this dummy example with the cmake build system.
+  inc/PDummyUserFcn.h  <- header file definig the needed classes for
+                          the user function and its globale part. 
+  inc/PDummyUserFcnLinkDef.h <- Needed as a glue to generate the necessary
+                                root dictionaries.
+  src/CMakeLists.txt <- needed for the cmake build/install process.
+  src/PDummyUserFcn.cpp <- source code which implements all the necessary
+                           parts of the user function.
+  src/PDummyUserFcn.pc.in <- cmake input file to generate the propoer 
+                             pkg-config file for the library
+

src/external/DummyUserFcn/inc/PDummyUserFcn.h

@@ -0,0 +1,81 @@
+/***************************************************************************
+
+  PDummyUserFcn.h
+
+  Author: Andreas Suter
+  e-mail: andreas.suter@psi.ch
+
+***************************************************************************/
+
+/***************************************************************************
+ *   Copyright (C) 2013-2021 by Andreas Suter                              *
+ *   andreas.suter@psi.ch                                                  *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+
+#ifndef _PDUMMYUSERFNC_H_
+#define _PDUMMYUSERFNC_H_
+
+#include <vector>
+
+#include "PUserFcnBase.h"
+
+class PDummyUserFcnGlobal
+{
+  public:
+    PDummyUserFcnGlobal();
+    virtual ~PDummyUserFcnGlobal();
+
+    Bool_t IsValid() { return fValid; }
+    virtual void CalculatePol(const std::vector<Double_t> &param) const;
+    virtual Double_t GetPolValue(const Double_t t) const;
+
+  private:
+    Bool_t fValid{true};
+
+    mutable std::vector<Double_t> fPreviousParam;
+
+    mutable Double_t fTimeStep{1.0e-3}; // time in (us), time step 1 (ns) here
+    mutable std::vector<Double_t> fPol;
+
+  ClassDef(PDummyUserFcnGlobal, 1)
+};
+
+class PDummyUserFcn : public PUserFcnBase
+{
+  public:
+    PDummyUserFcn() {}
+    virtual ~PDummyUserFcn();
+
+    virtual Bool_t NeedGlobalPart() const { return true; }
+    virtual void SetGlobalPart(std::vector<void*> &globalPart, UInt_t idx);
+    virtual Bool_t GlobalPartIsValid() const;
+
+    virtual Double_t operator()(Double_t t, const std::vector<Double_t> &param) const;
+
+  private:
+    Bool_t fValid{true};
+    Bool_t fInvokedGlobal{false};
+    Int_t fIdxGlobal;
+
+    PDummyUserFcnGlobal *fDummyUserFcnGlobal{nullptr};
+
+  // definition of the class for the ROOT dictionary
+  ClassDef(PDummyUserFcn, 1)
+};
+
+#endif // _PDUMMYUSERFNC_H_

src/external/DummyUserFcn/inc/PDummyUserFcnLinkDef.h

@@ -0,0 +1,39 @@
+/***************************************************************************
+
+  PDummyUserFcnLinkDef.h
+
+  Author: Andreas Suter
+  e-mail: andreas.suter@psi.ch
+
+***************************************************************************/
+
+/***************************************************************************
+ *   Copyright (C) 2013-2021 by Andreas Suter                              *
+ *   andreas.suter@psi.ch                                                  *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+
+#ifdef __CINT__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class PDummyUserFcnGlobal+;
+#pragma link C++ class PDummyUserFcn+;
+
+#endif

src/external/DummyUserFcn/src/CMakeLists.txt

@@ -0,0 +1,78 @@
+# - DummyUserFcn library --------------------------------------------------------
+
+#--- generate necessary dictionaries ------------------------------------------
+set(MUSRFIT_INC ${CMAKE_SOURCE_DIR}/src/include)
+set(DUMMY_USER_FUNC_INC ${CMAKE_CURRENT_SOURCE_DIR}/../inc)
+# ROOT requires that the dictonary header files are found at configuration time.
+# Hence, target_include_directories cannot be used here because, targets are 
+# setup only afterwards.
+include_directories(${DUMMY_USER_FUNC_INC})
+
+root_generate_dictionary(
+  PDummyUserFcnDict 
+  PDummyUserFcn.h 
+  OPTIONS 
+    -I${FFTW3_INCLUDE_DIR} 
+    -I${MUSRFIT_INC}
+    -I${DUMMY_USER_FUNC_INC}
+    -inlineInputHeader
+  LINKDEF ${DUMMY_USER_FUNC_INC}/PDummyUserFcnLinkDef.h
+  MODULE PDummyUserFcn
+)
+
+#--- create pkg-config info ---------------------------------------------------
+set(prefix "${CMAKE_INSTALL_PREFIX}")   
+set(exec_prefix "\$\{prefix\}")
+set(libdir "\$\{exec_prefix\}/lib")
+set(includedir "\$\{prefix\}/include")   
+set(P_DUMMY_USER_FUNC_VERSION "1.0.0")
+set(P_DUMMY_USER_FUNC_LIBRARY_NAME "PDummyUserFcn")
+configure_file("PDummyUserFcn.pc.in" "PDummyUserFcn.pc" @ONLY)
+
+#--- lib creation -------------------------------------------------------------
+add_library(PDummyUserFcn SHARED
+  PDummyUserFcn.cpp
+  PDummyUserFcnDict.cxx
+)
+
+#--- set target properties, e.g. version --------------------------------------
+set_target_properties(PDummyUserFcn
+  PROPERTIES
+    VERSION ${P_DUMMY_USER_FUNC_VERSION}
+)
+
+#--- make sure that the include directory is found ----------------------------
+target_include_directories(
+  PDummyUserFcn BEFORE PRIVATE 
+    $<BUILD_INTERFACE:${FFTW3_INCLUDE_DIR}> 
+    $<BUILD_INTERFACE:${MUSRFIT_INC}>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../inc>
+)
+
+#--- add library dependencies -------------------------------------------------
+target_link_libraries(PDummyUserFcn ${FFTW3_LIBRARY} ${ROOT_LIBRARIES} PUserFcnBase)
+
+#--- install PDummyUserFcn solib -------------------------------------------------
+install(TARGETS PDummyUserFcn DESTINATION lib)
+
+#--- install root pcm's and rootmaps ------------------------------------------
+install(
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/libPDummyUserFcn_rdict.pcm 
+        ${CMAKE_CURRENT_BINARY_DIR}/libPDummyUserFcn.rootmap
+  DESTINATION lib
+)
+
+#--- install PDummyUserFcn header ------------------------------------------------
+install(
+  FILES 
+    ${CMAKE_CURRENT_SOURCE_DIR}/../inc/PDummyUserFcn.h 
+  DESTINATION 
+    include
+)
+
+#--- install pkg-config info --------------------------------------------------
+install(
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/PDummyUserFcn.pc
+  DESTINATION lib/pkgconfig
+)
+

src/external/DummyUserFcn/src/PDummyUserFcn.cpp

@@ -0,0 +1,227 @@
+/***************************************************************************
+
+  PDummyUserFcn.cpp
+
+  Author: Andreas Suter
+  e-mail: andreas.suter@psi.ch
+
+***************************************************************************/
+
+/***************************************************************************
+ *   Copyright (C) 2009-2021 by Andreas Suter                              *
+ *   andreas.suter@psi.ch                                                  *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+
+#include <cassert>
+#include <cmath>
+
+#include <iostream>
+
+#include <TMath.h>
+
+#include "PDummyUserFcn.h"
+
+
+ClassImp(PDummyUserFcnGlobal)
+
+//--------------------------------------------------------------------------
+// Constructor
+//--------------------------------------------------------------------------
+/**
+ * <p>Here would go all the stuff which will be needed by the global part.
+ * For instance specific information which come from a startup XML file.
+ * This could be case if muon-stopping information is needed for the
+ * calculation, or any other user function specific stuff which is not
+ * part of the parameters which will be propagated from the msr-file.
+ */
+PDummyUserFcnGlobal::PDummyUserFcnGlobal()
+{
+  // nothing needed here for the dummy
+}
+
+//--------------------------------------------------------------------------
+// Destructor
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+PDummyUserFcnGlobal::~PDummyUserFcnGlobal()
+{
+  fPreviousParam.clear();
+  fPol.clear();
+}
+
+//--------------------------------------------------------------------------
+// CalculatePol (public)
+//--------------------------------------------------------------------------
+/**
+ * <p>Calculates the polarization function for the dummy user function.
+ * For the Dummy this is just an exp(-lambda t), where lambda is comming
+ * from the param.
+ *
+ * \param param the parameter for this user function
+ */
+void PDummyUserFcnGlobal::CalculatePol(const std::vector<Double_t> &param) const
+{
+  // param: [0] lambda
+
+  // check that param is new and hence a calculation is needed
+  Bool_t newParams = false;
+  if (fPreviousParam.size() == 0) {
+    for (UInt_t i=0; i<param.size(); i++)
+      fPreviousParam.push_back(param[i]);
+    newParams = true;
+  } else {
+    assert(param.size() == fPreviousParam.size());
+
+    for (UInt_t i=0; i<param.size(); i++) {
+      if (param[i] != fPreviousParam[i]) {
+        newParams = true;
+        break;
+      }
+    }
+  }
+
+  if (!newParams)
+    return;
+
+  // keep parameters
+  for (UInt_t i=0; i<param.size(); i++)
+    fPreviousParam[i] = param[i];
+
+  // calculate the "polarization" in the time interval t = [0, 20] us
+  Double_t dt = fTimeStep, t = 0.0;
+  Int_t noOfPoints = 20.0 / dt;
+  fPol.resize(noOfPoints); // this makes sure that the polarization vector is long enough
+  for (Int_t i=0; i<noOfPoints; i++) {
+    t = i*dt;
+    fPol[i] = exp(-param[0] * i * dt);
+  }
+}
+
+//--------------------------------------------------------------------------
+// GetMagneticField
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+Double_t PDummyUserFcnGlobal::GetPolValue(const Double_t t) const
+{
+  Double_t result = -1.0;
+
+  if (t < 0)
+    return 1.0;
+
+  if (t >= 20.0)
+    return 0.0;
+
+  Int_t idx = (Int_t)(t/fTimeStep);
+
+  if ((idx >=0) && (idx < fPol.size()))
+    result = fPol[idx];
+
+  return result;
+}
+
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+ClassImp(PDummyUserFcn)
+
+//--------------------------------------------------------------------------
+// Destructor
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+PDummyUserFcn::~PDummyUserFcn()
+{
+  if ((fDummyUserFcnGlobal != nullptr) && fInvokedGlobal) {
+    delete fDummyUserFcnGlobal;
+    fDummyUserFcnGlobal = nullptr;
+  }
+}
+
+//--------------------------------------------------------------------------
+// SetGlobalPart (public)
+//--------------------------------------------------------------------------
+/**
+ * <p>
+ *
+ * <b>return:</b>
+ *
+ * \param globalPart
+ * \param idx
+ */
+void PDummyUserFcn::SetGlobalPart(std::vector<void*> &globalPart, UInt_t idx)
+{
+  fIdxGlobal = static_cast<Int_t>(idx);
+
+  if ((Int_t)globalPart.size() <= fIdxGlobal) {
+    fDummyUserFcnGlobal = new PDummyUserFcnGlobal();
+    if (fDummyUserFcnGlobal == nullptr) {
+      fValid = false;
+      std::cerr << std::endl << ">> PDummyUserFcn::SetGlobalPart(): **ERROR** Couldn't invoke global user function object, sorry ..." << std::endl;
+    } else if (!fDummyUserFcnGlobal->IsValid()) {
+      fValid = false;
+      std::cerr << std::endl << ">> PDummyUserFcn::SetGlobalPart(): **ERROR** initialization of global user function object failed, sorry ..." << std::endl;
+    } else {
+      fValid = true;
+      fInvokedGlobal = true;
+      globalPart.resize(fIdxGlobal+1);
+      globalPart[fIdxGlobal] = dynamic_cast<PDummyUserFcnGlobal*>(fDummyUserFcnGlobal);
+    }
+  } else {
+    fValid = true;
+    fDummyUserFcnGlobal = (PDummyUserFcnGlobal*)globalPart[fIdxGlobal];
+  }
+}
+
+//--------------------------------------------------------------------------
+// GlobalPartIsValid (public)
+//--------------------------------------------------------------------------
+/**
+ * <p>
+ *
+ * <b>return:</b>
+ */
+Bool_t PDummyUserFcn::GlobalPartIsValid() const
+{
+  return (fValid && fDummyUserFcnGlobal->IsValid());
+}
+
+//--------------------------------------------------------------------------
+// operator()
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+Double_t PDummyUserFcn::operator()(Double_t t, const std::vector<Double_t> &param) const
+{
+  // param: [0] lambda
+  assert(param.size() == 1);
+
+  // for negative time return polarization == 1
+  if (t <= 0.0)
+    return 1.0;
+
+  // calculate field if parameter have changed
+  fDummyUserFcnGlobal->CalculatePol(param);
+
+  // return the lookup table value
+  return fDummyUserFcnGlobal->GetPolValue(t);
+}

src/external/DummyUserFcn/src/PDummyUserFcn.pc.in

@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: PDummyUserFcn
+Description: C++ shared library providing the spin valve fitter class
+Version: @P_DUMMY_USER_FUNC_VERSION@
+Libs: -L${libdir} -l@P_DUMMY_USER_FUNC_LIBRARY_NAME@
+Cflags: -I${includedir}

src/external/MuSR_software/Class_MuSR_PSI/MuSR_td_PSI_bin.cpp

@@ -116,6 +116,13 @@ MuSR_td_PSI_bin::MuSR_td_PSI_bin()
    file_name.close();
    delete [] buffer_file;
 
+   if (format_id[0] == '1') {
+     if (format_id[1] != 'N') {
+       std::cout << "**WARNING** found '" << format_id << "'. Will change it to '1N'" << std::endl;
+       format_id[1] = 'N';
+     }
+   }
+
    // file may either be PSI binary format
    if (strncmp(format_id,"1N",2) == 0)
    {
@@ -306,6 +313,9 @@ int MuSR_td_PSI_bin::readbin(const char * fileName)
   strncpy(format_id,buffer_file,2);
   format_id[2] = '\0';
 
+  if (format_id[1] != 'N') // the warning is already issued in read()
+    format_id[1] = 'N';
+
   if (strcmp(format_id,"1N") != 0)
   {
     file_name.close();

src/external/mud/src/mud.c

@@ -23,10 +23,10 @@
  *   v1.2   08-Oct-2000  [D. Arseneau] Add MUD_setSizes
  *   v1.3   22-Apr-2003  [D. Arseneau] Add MUD_openInOut
  *          25-Nov-2009  [D. Arseneau] Handle larger size_t
+ *          04-May-2016  [D. Arseneau] Edits for C++ use
  */
 
 
-#include <stdio.h>
 #include "mud.h"
 
 #ifdef NO_STDARG
@@ -35,11 +35,10 @@
 #include <stdarg.h>
 #endif /* NO_STDARG */
 
-/* #define DEBUG 1   /* un-comment for debug */ 
+/* #define DEBUG 1 */  /* un-comment for debug */ 
 
 FILE*
-MUD_openInput( inFile )
+MUD_openInput( char* inFile )
-    char* inFile;
 {
     FILE* fin;
 
@@ -53,8 +52,7 @@ MUD_openInput( inFile )
 
 /* This is the same as MUD_openInput except for access mode */
 FILE*
-MUD_openInOut( inFile )
+MUD_openInOut( char* inFile )
-    char* inFile;
 {
     FILE* fin;
 
@@ -68,8 +66,7 @@ MUD_openInOut( inFile )
 
 
 FILE* 
-MUD_openOutput( outFile )
+MUD_openOutput( char* outFile )
-    char* outFile;
 {
     FILE* fout;
 
@@ -83,8 +80,7 @@ MUD_openOutput( outFile )
 
 
 void
-MUD_free( pMUD )
+MUD_free( void* pMUD )
-    void* pMUD;
 {
     if( pMUD != NULL ) MUD_free( ((MUD_SEC*)pMUD)->core.pNext );
     else return;
@@ -101,10 +97,7 @@ MUD_free( pMUD )
 
 
 BOOL
-MUD_encode( pBuf, pMUD, io_opt )
+MUD_encode( BUF* pBuf, void* pMUD, MUD_IO_OPT io_opt )
-    BUF* pBuf;
-    void* pMUD;
-    MUD_IO_OPT io_opt;
 {
     if( pMUD == NULL ) return( TRUE );
 
@@ -130,7 +123,7 @@ MUD_encode( pBuf, pMUD, io_opt )
 	printf( "MUD_encode:  buf.buf  = %08X\n", pBuf->buf );
 #endif /* DEBUG */
 
-    MUD_CORE_proc( MUD_ENCODE, pBuf, pMUD );
+    MUD_CORE_proc( MUD_ENCODE, pBuf, (MUD_SEC*)pMUD );
     (*((MUD_SEC*)pMUD)->core.proc)( MUD_ENCODE, pBuf, (void*)pMUD );
 
     if( ( MUD_secID( pMUD ) == MUD_SEC_GRP_ID ) && 
@@ -155,8 +148,7 @@ MUD_encode( pBuf, pMUD, io_opt )
 
 
 void*
-MUD_decode( pBuf )
+MUD_decode( BUF* pBuf )
-    BUF* pBuf;
 {
     MUD_SEC* pMUD;
     MUD_SEC mud;
@@ -199,23 +191,20 @@ MUD_decode( pBuf )
 
 
 int
-MUD_getSize( pMUD )
+MUD_getSize( void* pMUD )
-    void* pMUD;
 {
-    return( MUD_CORE_proc( MUD_GET_SIZE, NULL, pMUD ) +
+    return( MUD_CORE_proc( MUD_GET_SIZE, NULL, (MUD_SEC*)pMUD ) +
-	    (*((MUD_SEC*)pMUD)->core.proc)( MUD_GET_SIZE, NULL, (void*)pMUD ) );
+	    (*((MUD_SEC*)pMUD)->core.proc)( MUD_GET_SIZE, NULL, pMUD ) );
 }
 
 
 void
-MUD_show( pMUD, io_opt )
+MUD_show( void* pMUD, MUD_IO_OPT io_opt )
-    void* pMUD;
-    MUD_IO_OPT io_opt;
 {
     if( pMUD == NULL ) return;
 
-    MUD_CORE_proc( MUD_SHOW, NULL, pMUD );
+    MUD_CORE_proc( MUD_SHOW, NULL, (MUD_SEC*)pMUD );
-    (*((MUD_SEC*)pMUD)->core.proc)( MUD_SHOW, NULL, (void*)pMUD );
+    (*((MUD_SEC*)pMUD)->core.proc)( MUD_SHOW, NULL, pMUD );
 
     printf( "\n" );
 
@@ -233,14 +222,12 @@ MUD_show( pMUD, io_opt )
 }
 
 void
-MUD_heads( pMUD, io_opt )
+MUD_heads( void* pMUD, MUD_IO_OPT io_opt )
-    void* pMUD;
-    MUD_IO_OPT io_opt;
 {
     if( pMUD == NULL ) return;
 
-    MUD_CORE_proc( MUD_HEADS, NULL, pMUD );
+    MUD_CORE_proc( MUD_HEADS, NULL, (MUD_SEC*)pMUD );
-    (*((MUD_SEC*)pMUD)->core.proc)( MUD_HEADS, NULL, (void*)pMUD );
+    (*((MUD_SEC*)pMUD)->core.proc)( MUD_HEADS, NULL, pMUD );
 
     if( ( MUD_secID( pMUD ) == MUD_SEC_GRP_ID ) && 
 	( io_opt == MUD_ALL ) )
@@ -260,8 +247,7 @@ MUD_heads( pMUD, io_opt )
  *  MUD_writeEnd() - called after all writes to file
  */	  
 BOOL
-MUD_writeEnd( fout )
+MUD_writeEnd( FILE* fout )
-    FILE* fout;
 {
     MUD_SEC_EOF* pMUD_eof;
 
@@ -282,9 +268,7 @@ MUD_writeEnd( fout )
  *  MUD_writeFile() - use for completely assembled groups/sections
  */	  
 BOOL
-MUD_writeFile( fout, pMUD_head )
+MUD_writeFile( FILE* fout, void* pMUD_head )
-    FILE* fout;
-    void* pMUD_head;
 {
     rewind( fout );
     if( !MUD_write( fout, pMUD_head, MUD_ALL ) ) return( FALSE );
@@ -296,10 +280,7 @@ MUD_writeFile( fout, pMUD_head )
  *  MUD_write() - use for completely assembled groups/sections
  */	  
 BOOL
-MUD_write( fout, pMUD, io_opt )
+MUD_write( FILE* fout, void* pMUD, MUD_IO_OPT io_opt )
-    FILE* fout;
-    void* pMUD;
-    MUD_IO_OPT io_opt;
 {
     BUF buf;
 
@@ -328,12 +309,8 @@ MUD_write( fout, pMUD, io_opt )
  *	MUD_writeEnd()
  */
 BOOL
-MUD_writeGrpStart( fout, pMUD_parentGrp, 
+MUD_writeGrpStart( FILE* fout, MUD_SEC_GRP* pMUD_parentGrp, 
-		   pMUD_grp, numMems )
+		   MUD_SEC_GRP* pMUD_grp, int numMems )
-    FILE* fout;
-    MUD_SEC_GRP* pMUD_parentGrp;
-    MUD_SEC_GRP* pMUD_grp;
-    int numMems;
 {
     pMUD_grp->pParent = pMUD_parentGrp;
 
@@ -352,9 +329,7 @@ MUD_writeGrpStart( fout, pMUD_parentGrp,
 
 
 void
-addIndex( pMUD_grp, pMUD )
+addIndex( MUD_SEC_GRP* pMUD_grp, void* pMUD )
-    MUD_SEC_GRP* pMUD_grp;
-    void* pMUD;
 {
     MUD_INDEX** ppMUD_index;
 
@@ -373,10 +348,7 @@ addIndex( pMUD_grp, pMUD )
  *  MUD_writeGrpMem() - use for writes of unassembled groups
  */	  
 BOOL
-MUD_writeGrpMem( fout, pMUD_grp, pMUD )
+MUD_writeGrpMem( FILE* fout, MUD_SEC_GRP* pMUD_grp, void* pMUD )
-    FILE* fout;
-    MUD_SEC_GRP* pMUD_grp;
-    void* pMUD;
 {
     ((MUD_SEC*)pMUD)->core.size = MUD_getSize( pMUD );
 
@@ -401,9 +373,7 @@ MUD_writeGrpMem( fout, pMUD_grp, pMUD )
  *  MUD_writeGrpEnd() - use for writes of unassembled groups
  */	  
 BOOL
-MUD_writeGrpEnd( fout, pMUD_grp )
+MUD_writeGrpEnd( FILE* fout, MUD_SEC_GRP* pMUD_grp )
-    FILE* fout;
-    MUD_SEC_GRP* pMUD_grp;
 {
     int pos;
 
@@ -425,8 +395,7 @@ MUD_writeGrpEnd( fout, pMUD_grp )
 
 
 void*
-MUD_readFile( fin )
+MUD_readFile( FILE* fin )
-    FILE* fin;
 {
     rewind( fin );
 
@@ -435,9 +404,7 @@ MUD_readFile( fin )
 
 
 void*
-MUD_read( fin, io_opt )
+MUD_read( FILE* fin, MUD_IO_OPT io_opt )
-    FILE* fin;
-    MUD_IO_OPT io_opt;
 {
     BUF buf;
     MUD_SEC* pMUD_new;
@@ -459,7 +426,7 @@ MUD_read( fin, io_opt )
     if( fseek( fin, pos, 0 ) == EOF ) return( NULL );
 
 #ifdef DEBUG
-    printf( "MUD_read: got %d\n", size );
+    printf( "MUD_read: got %lu\n", (unsigned long)(size) );
     printf( "          pos = %d\n", pos );
     printf( "          reading the section ...\n" );
 #endif /* DEBUG */
@@ -572,8 +539,7 @@ MUD_read( fin, io_opt )
  */
 
 UINT32
-MUD_setSizes( pMUD )
+MUD_setSizes( void* pMUD )
-    void* pMUD;
 {
     MUD_SEC*    pMember;
     MUD_INDEX*  pGrpIndex;
@@ -624,8 +590,7 @@ MUD_setSizes( pMUD )
 
 
 MUD_SEC*
-MUD_peekCore( fin )
+MUD_peekCore( FILE* fin )
-    FILE* fin;
 {
     static MUD_SEC mud;
     int pos;
@@ -847,12 +812,8 @@ MUD_fseek( FILE* fio, ... )
 
 
 MUD_SEC*
-fseekNext( fio, pMUD_parent, 
+fseekNext( FILE* fio, MUD_SEC_GRP* pMUD_parent, 
-	   secID, instanceID )
+	   UINT32 secID, UINT32 instanceID )
-    FILE* fio;
-    MUD_SEC_GRP* pMUD_parent;
-    UINT32 secID;
-    UINT32 instanceID;
 {
     MUD_SEC* pMUD;
     MUD_INDEX* pMUD_index;
@@ -920,8 +881,7 @@ fseekNext( fio, pMUD_parent,
 
 
 int
-MUD_fseekFirst( fio )
+MUD_fseekFirst( FILE* fio )
-    FILE* fio;
 {
     int size;
 
@@ -935,9 +895,7 @@ MUD_fseekFirst( fio )
 
 
 void
-MUD_add( ppMUD_head, pMUD_new )
+MUD_add( void** ppMUD_head, void* pMUD_new )
-    void** ppMUD_head;
-    void* pMUD_new;
 {
     MUD_SEC** ppMUD;
 
@@ -952,8 +910,7 @@ MUD_add( ppMUD_head, pMUD_new )
 
 
 int
-MUD_totSize( pMUD )
+MUD_totSize( void* pMUD )
-    void* pMUD;
 {
     return( ( MUD_secID( pMUD ) == MUD_SEC_GRP_ID ) ? 
 		MUD_size( pMUD ) + ((MUD_SEC_GRP*)pMUD)->memSize : 
@@ -962,14 +919,13 @@ MUD_totSize( pMUD )
 
 
 void
-MUD_addToGroup( pMUD_grp, pMUD )
+MUD_addToGroup( MUD_SEC_GRP* pMUD_grp, void* pMUD )
-    MUD_SEC_GRP* pMUD_grp;
-    void* pMUD;
 {
     MUD_SEC** ppMUD;
 
     if( pMUD == NULL ) return;
 
+    /* possible addition: ((MUD_SEC*)pMUD)->core.pNext = NULL; */
     ((MUD_SEC*)pMUD)->core.size = MUD_getSize( pMUD );
 
     for( ppMUD = &pMUD_grp->pMem; 
@@ -985,9 +941,7 @@ MUD_addToGroup( pMUD_grp, pMUD )
 
 
 void
-MUD_assignCore( pMUD1, pMUD2 )
+MUD_assignCore( MUD_SEC* pMUD1, MUD_SEC* pMUD2 )
-    MUD_SEC* pMUD1;
-    MUD_SEC* pMUD2;
 {
     bcopy( &pMUD1->core.size, &pMUD2->core.size, 
 	    MUD_CORE_proc( MUD_GET_SIZE, NULL, NULL ) );
@@ -995,10 +949,7 @@ MUD_assignCore( pMUD1, pMUD2 )
 
 
 int
-MUD_CORE_proc( op, pBuf, pMUD )
+MUD_CORE_proc( MUD_OPT op, BUF* pBuf, MUD_SEC* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC* pMUD;
 {
     int size;
 
@@ -1019,12 +970,13 @@ MUD_CORE_proc( op, pBuf, pMUD )
 	case MUD_GET_SIZE:
 	    size = 3*sizeof(UINT32);
 #ifdef DEBUG
-    printf("MUD_CORE_proc: MUD_GET_SIZE returns size=%d\n",size);
+            printf("MUD_CORE_proc: MUD_GET_SIZE returns size=%d\n",size);
 #endif /* DEBUG */            
 	    return( size );
 	case MUD_SHOW:
-	    printf( "  CORE: size=[%ld], secID=[0x%08lX], instanceID=[0x%08lX]\n",
+	    printf( "  CORE: size=[%lu], secID=[0x%08lX], instanceID=[0x%08lX]\n",
-		    pMUD->core.size, pMUD->core.secID, pMUD->core.instanceID );
+		    (unsigned long)(pMUD->core.size), (unsigned long)(pMUD->core.secID), 
+                    (unsigned long)(pMUD->core.instanceID) );
 	    break;
 	case MUD_HEADS:
 	    break;
@@ -1034,10 +986,7 @@ MUD_CORE_proc( op, pBuf, pMUD )
 
 
 int
-MUD_INDEX_proc( op, pBuf, pMUD )
+MUD_INDEX_proc( MUD_OPT op, BUF* pBuf, MUD_INDEX* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_INDEX* pMUD;
 {
     int size;
 
@@ -1065,8 +1014,9 @@ MUD_INDEX_proc( op, pBuf, pMUD )
 	    size = 3*sizeof(UINT32);
 	    return( size );
 	case MUD_SHOW:
-	    printf( "  INDEX: offset=[%ld], secID=[0x%08lX], instanceID=[0x%08lX]\n",
+	    printf( "  INDEX: offset=[%lu], secID=[0x%08lX], instanceID=[0x%08lX]\n",
-		    pMUD->offset, pMUD->secID, pMUD->instanceID );
+		    (unsigned long)(pMUD->offset), (unsigned long)(pMUD->secID), 
+                    (unsigned long)(pMUD->instanceID) );
 	    break;
 	case MUD_HEADS:
 	    break;

src/external/mud/src/mud.h

@@ -1,19 +1,39 @@
 #ifndef _MUD_H_
 #define _MUD_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
- * v1.2
+ * mud.h  Declarations for MUD 
+ * v1.3
+ *
+ *   Copyright (C) 1994-2021 TRIUMF (Vancouver, Canada)
+ *
+ *   Authors: T. Whidden, D. Arseneau, S. Daviel
+ *   
+ *   Released under the GNU LGPL - see http://www.gnu.org/licenses
+ *
+ *   This program is free software; you can distribute it and/or modify it under 
+ *   the terms of the Lesser GNU General Public License as published by the Free 
+ *   Software Foundation; either version 2 of the License, or any later version. 
+ *   Accordingly, this program is distributed in the hope that it will be useful, 
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
+ *   or FITNESS FOR A PARTICULAR PURPOSE. See the Lesser GNU General Public License 
+ *   for more details.
  *
  * revisions:
  * 01-mar-2000   DJA  add UNKNOWN section, with no ID 
  * 11-oct-2000   DJA  add MUD_FMT_RAL_ID; MUD_setSizes
  * 22-Apr-2003   DJA  add MUD_openReadWrite, MUD_openInOut
+ * 25-Nov-2009   DJA  64-bit linux
+ * 25-Jun-2017   DJA  Allow use in C++ (ROOT); shared lib.
+ * 14-Aug-2019   DJA  Use stdint.h, casts in printf
  */
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __CINT__
+typedef char* caddr_t;
+#endif /* __CINT __ */
+
 /*
  *  FORMAT IDs - Must be unique!
  *               format of ID is:  0xLLFFSSSS
@@ -94,31 +114,49 @@ extern "C" {
 #include <stddef.h>
 #include <sys/types.h>
 
+#ifndef NOSTDINT
+/* If there is no stdint.h, define NOSTDINT, as with "make NOSTDINT=1" */
+#include <stdint.h>
+#endif
+
 /*
  *  MUD types
  */
+
+#ifdef _STDINT_H
+typedef int			STATUS;
+typedef int8_t			INT8;
+typedef uint8_t			UINT8;
+typedef int16_t			INT16;
+typedef uint16_t 		UINT16;
+typedef int32_t			INT32;
+typedef uint32_t		UINT32;
+typedef float			REAL32;
+typedef double			REAL64;
+#else /*no stding.h */
 typedef int			STATUS;
 typedef char			INT8;
 typedef unsigned char		UINT8;
 typedef short			INT16;
 typedef unsigned short		UINT16;
-#if defined(__alpha) || defined(__x86_64__) || defined(__amd64) || defined(__ia64)
+#if defined(__alpha) || defined(__linux) || defined(__MACH__) || defined(__arm64)
 typedef int			INT32;
 typedef unsigned int		UINT32;
 #else
 typedef long			INT32;
 typedef unsigned long		UINT32;
-#endif /* defined(__alpha) || defined(__x86_64__) || defined(__amd64) || defined(__ia64) */
+#endif /* __alpha || __linux || __MACH__*/
 typedef float			REAL32;
 typedef double			REAL64;
+#if (defined(__alpha)&&defined(vms)) || defined(__BORLANDC__) || defined(__TURBOC__)
+typedef char* 			caddr_t;
+#endif
+#endif /* _STDINT_HNOSTDINT */
 typedef UINT32                  TIME;
 #ifndef BOOL_DEFINED
 #define BOOL_DEFINED
 typedef UINT32                  BOOL;
 #endif
-#if (defined(__alpha)&&defined(vms)) || defined(__BORLANDC__) || defined(__TURBOC__)
-typedef char* 			caddr_t;
-#endif
 
 #ifndef FALSE
 #define FALSE	0
@@ -146,10 +184,10 @@ typedef char* 			caddr_t;
 /*
  *  c_utils.h,  Defines for C utilities
  */
-#if defined(vms) || defined(__MSDOS__) || defined(_MSC_VER)
+#if defined(vms) || defined(__MSDOS__)
 #define bcopy( b1, b2, len )		memcpy(b2,b1,len)
 #define bzero( b, len )			memset(b,(char)0,len)
-#endif /* vms || __MSDOS__ || _MSC_VER */
+#endif /* vms || __MSDOS__ */
 #ifndef _C_UTILS_H_   /* conflict with c_utils.h */
 #define _max( a, b )			( ( (a) > (b) ) ? (a) : (b) )
 #define _min( a, b )			( ( (a) < (b) ) ? (a) : (b) )
@@ -157,11 +195,12 @@ typedef char* 			caddr_t;
 #define _swap32( l )                    (((UINT32)l>>16)+((UINT32)l<<16))
 #define _swap16( s )                    (((UINT16)s>>8)+((UINT16)s<<8))
 #endif
-#define _free(objp)			if(objp!=NULL){free(objp);objp=NULL;}
+
-#define  _roundUp( n, r )		( (r) * (int)( ((n)+(r)-1) / (r) ) )
+#define _free(objp)			if((void*)(objp)!=(void*)NULL){free((void*)(objp));objp=NULL;}
+#define _roundUp( n, r )		( (r) * (int)( ((n)+(r)-1) / (r) ) )
 
 #define zalloc( n )			memset((void*)malloc(n),0,n)
-#if defined(vms) || (defined(mips)&&!defined(__sgi)) || ((defined(__MSDOS__) || defined(_MSC_VER))&&defined(__STDC__))
+#if defined(vms) || (defined(mips)&&!defined(__sgi)) || (defined(__MSDOS__)&&defined(__STDC__))
 #define strdup( s )			strcpy((char*)malloc(strlen(s)+1),s)
 #endif /* vms || mips&&!sgi */
 /*#endif */
@@ -388,8 +427,7 @@ typedef struct {
 #define MUD_instanceID( pM )	(((MUD_SEC*)pM)->core.instanceID)
 
 
-#if defined(__MSDOS__) || defined(__i386__) || defined(__i586__) || defined(__i686__) || defined(vax) || defined(__alpha) || defined(__x86_64__) || defined(__amd64) \
+#if defined(__MSDOS__) || defined(__i386__) || defined(__i586__) || defined(__i686__) || defined(vax) || defined(__alpha) || defined(__amd64) || defined(__arm64) || (defined(__mips)&&!defined(__sgi))
-                       || (defined(__mips)&&!defined(__sgi))
 #define MUD_LITTLE_ENDIAN 1
 #else
 #define MUD_BIG_ENDIAN 1
@@ -524,9 +562,9 @@ int MUD_SEC_GEN_HIST_unpack _ANSI_ARGS_(( int num , int inBinSize , void* inHist
 int MUD_SEC_TRI_TI_RUN_DESC_proc _ANSI_ARGS_(( MUD_OPT op , BUF *pBuf , MUD_SEC_TRI_TI_RUN_DESC *pMUD ));
 
 /* gmf_time.c */
-void GMF_MKTIME _ANSI_ARGS_(( time_t* out , INT32* input ));
+void GMF_MKTIME _ANSI_ARGS_(( TIME* out , INT32* input ));
-void GMF_TIME _ANSI_ARGS_(( time_t* out ));
+void GMF_TIME _ANSI_ARGS_(( TIME* out ));
-void GMF_LOCALTIME _ANSI_ARGS_(( time_t* in , INT32 *out ));
+void GMF_LOCALTIME _ANSI_ARGS_(( TIME* in , INT32 *out ));
 
 /* mud_friendly.c */
 int MUD_openRead _ANSI_ARGS_(( char* filename, UINT32* pType ));

src/external/mud/src/mud_all.c

@@ -27,13 +27,8 @@
 
 
 int
-MUD_SEC_proc( op, pBuf, pMUD )
+MUD_SEC_proc( MUD_OPT op, BUF* pBuf, MUD_SEC* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC* pMUD;
 {
-    int size;
-
     switch( op )
     {
 	case MUD_FREE:
@@ -55,13 +50,8 @@ MUD_SEC_proc( op, pBuf, pMUD )
 
 
 int
-MUD_SEC_EOF_proc( op, pBuf, pMUD )
+MUD_SEC_EOF_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_EOF* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_EOF* pMUD;
 {
-    int size;
-
     switch( op )
     {
 	case MUD_FREE:
@@ -83,10 +73,7 @@ MUD_SEC_EOF_proc( op, pBuf, pMUD )
 
 
 int
-MUD_SEC_FIXED_proc( op, pBuf, pMUD )
+MUD_SEC_FIXED_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_FIXED* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_FIXED* pMUD;
 {
     int size;
 
@@ -106,8 +93,8 @@ MUD_SEC_FIXED_proc( op, pBuf, pMUD )
 	    size = 2*sizeof( UINT32 );
 	    return( size );
 	case MUD_SHOW:
-	    printf( "  MUD_SEC_FIXED: fileSize=[%ld], formatID=[0x%08lX]\n",
+	    printf( "  MUD_SEC_FIXED: fileSize=[%lu], formatID=[0x%08lX]\n",
-		    pMUD->fileSize, pMUD->formatID );
+		    (unsigned long)(pMUD->fileSize), (unsigned long)(pMUD->formatID) );
 	    break;
 	case MUD_HEADS:
 	    break;
@@ -117,10 +104,7 @@ MUD_SEC_FIXED_proc( op, pBuf, pMUD )
 
 
 int
-MUD_SEC_GRP_proc( op, pBuf, pMUD )
+MUD_SEC_GRP_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GRP* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_GRP* pMUD;
 {
     int size;
     int i;
@@ -160,7 +144,7 @@ MUD_SEC_GRP_proc( op, pBuf, pMUD )
 	    return( size );
 	case MUD_SHOW:
 	    printf( "  MUD_SEC_GRP: num=[%ld], memSize=%ld\n", 
-		    pMUD->num, pMUD->memSize );
+		    (long int)(pMUD->num), (long int)(pMUD->memSize) );
 	    for( pMUD_index = pMUD->pMemIndex;
 		 pMUD_index != NULL;
 		 pMUD_index = pMUD_index->pNext )
@@ -178,10 +162,7 @@ MUD_SEC_GRP_proc( op, pBuf, pMUD )
 
 
 int
-MUD_SEC_CMT_proc( op, pBuf, pMUD )
+MUD_SEC_CMT_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_CMT* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_CMT* pMUD;
 {
     int size;
     char tempStr1[32];
@@ -221,8 +202,9 @@ MUD_SEC_CMT_proc( op, pBuf, pMUD )
 	    return( size );
 	case MUD_SHOW:
 	    printf( "  MUD_SEC_CMT: \n" );
-	    printf( "    number:[%ld],  prevReply:[%ld],  nextReply:[%ld]\n", 
+	    printf( "    number:[%lu],  prevReply:[%lu],  nextReply:[%lu]\n", 
-			pMUD->ID, pMUD->prevReplyID, pMUD->nextReplyID );
+                    (unsigned long)(pMUD->ID), (unsigned long)(pMUD->prevReplyID),
+                    (unsigned long)(pMUD->nextReplyID) );
 	    bintime = pMUD->time;
 	    strncpy( tempStr1, ctime( &bintime ), sizeof(tempStr1) );
 	    tempStr1[strlen(tempStr1)-1] = '\0';
@@ -232,11 +214,11 @@ MUD_SEC_CMT_proc( op, pBuf, pMUD )
 	    if( pMUD->comment ) printf( "    comment:\"%s\"\n", pMUD->comment );
 	    break;
 	case MUD_HEADS:
-            printf( "Comment number %ld.     ", pMUD->ID );
+            printf( "Comment number %lu.     ", (unsigned long)(pMUD->ID) );
             if( pMUD->prevReplyID > 0 )
-              printf("  Re: #%ld.    ", pMUD->prevReplyID );
+              printf("  Re: #%lu.    ", (unsigned long)(pMUD->prevReplyID) );
             if( pMUD->nextReplyID > 0 )
-              printf("  Next: #%ld.", pMUD->nextReplyID );
+              printf("  Next: #%lu.", (unsigned long)(pMUD->nextReplyID) );
             printf( "\n" );
 	    bintime = pMUD->time;
 	    strncpy( tempStr1, ctime( &bintime ), sizeof(tempStr1) );
@@ -251,13 +233,8 @@ MUD_SEC_CMT_proc( op, pBuf, pMUD )
 
 
 int
-MUD_SEC_UNKNOWN_proc( op, pBuf, pMUD )
+MUD_SEC_UNKNOWN_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_UNKNOWN* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_UNKNOWN* pMUD;
 {
-    int size;
-
     switch( op )
     {
 	case MUD_FREE:

src/external/mud/src/mud_encode.c

@@ -21,15 +21,11 @@
  *  license (unrestricted use).
  */
 
-#include <stdio.h>
-
 #include "mud.h"
 
 
 void
-bdecode_2( b, p )
+bdecode_2( void* b, void* p )
-    void* b;
-    void* p;
 {
 #ifdef MUD_BIG_ENDIAN
   UINT16 i;
@@ -42,9 +38,7 @@ bdecode_2( b, p )
 }
 
 void
-bencode_2( b, p )
+bencode_2( void* b, void* p )
-    void* b;
-    void* p;
 {
 #ifdef MUD_BIG_ENDIAN
   UINT16 i;
@@ -63,9 +57,7 @@ bencode_2( b, p )
 }
 
 void
-bdecode_4( b, p )
+bdecode_4( void* b,void*  p )
-    void* b;
-    void* p;
 {
 #ifdef MUD_BIG_ENDIAN
   UINT32 i;
@@ -78,9 +70,7 @@ bdecode_4( b, p )
 }
 
 void
-bencode_4( b, p )
+bencode_4( void* b, void* p )
-    void* b;
-    void* p;
 {
 #ifdef MUD_BIG_ENDIAN
   UINT32 i;
@@ -93,9 +83,7 @@ bencode_4( b, p )
 }
 
 void
-bdecode_8( b, p )
+bdecode_8( void* b, void* p )
-    void* b;
-    void* p;
 {
 #ifdef MUD_BIG_ENDIAN
   UINT32 i[2], i2[2];
@@ -109,9 +97,7 @@ bdecode_8( b, p )
 }
 
 void
-bencode_8( b, p )
+bencode_8( void* b, void* p )
-    void* b;
-    void* p;
 {
 #ifdef MUD_BIG_ENDIAN
   UINT32 i[2], i2[2];
@@ -126,9 +112,7 @@ bencode_8( b, p )
 
 
 void
-decode_str( pB, ps )
+decode_str( BUF* pB, char** ps )
-    BUF* pB;
-    char** ps;
 {
     MUD_STR_LEN_TYPE len;
 
@@ -153,9 +137,7 @@ decode_str( pB, ps )
 
 
 void
-encode_str( pB, ps )
+encode_str( BUF* pB, char** ps )
-    BUF* pB;
-    char** ps;
 {
     MUD_STR_LEN_TYPE len;
 
@@ -223,16 +205,13 @@ static struct sgl_limits {
 #endif /* !VMS */
 
 void
-bencode_float( buf, fp )
+bencode_float( char* buf, float* fp )
-    char* buf;
-    float* fp;
 {
 #ifndef VMS
   struct ieee_single is;
   struct vax_single vs;
   struct sgl_limits *lim;
   int i;
-  UINT16 sa[2], sb[2];
 #endif /* !VMS */
 
 #ifdef VMS
@@ -262,9 +241,7 @@ shipit:
 }
 
 void
-encode_float( pBuf, fp )
+encode_float( BUF* pBuf, float* fp )
-    BUF* pBuf;
-    float* fp;
 {
   bencode_float( &(pBuf->buf[pBuf->pos]), fp );
   pBuf->pos += 4;
@@ -272,9 +249,7 @@ encode_float( pBuf, fp )
 }
 
 void
-bdecode_float( buf, fp )
+bdecode_float( char* buf, float* fp )
-    char* buf;
-    float* fp;
 {
 #ifndef VMS
   struct ieee_single *isp;
@@ -315,9 +290,7 @@ shipit:
 }
 
 void
-decode_float( pBuf, fp )
+decode_float( BUF* pBuf, float* fp )
-    BUF* pBuf;
-    float* fp;
 {
   bdecode_float( &(pBuf->buf[pBuf->pos]), fp );
   pBuf->pos += 4;
@@ -392,16 +365,13 @@ static struct dbl_limits {
 
 
 void
-bencode_double( buf, dp )
+bencode_double( char* buf, double* dp )
-    char* buf;
-    double* dp;
 {
 #ifndef VMS
   struct ieee_double id;
   struct vax_double vd;
   register struct dbl_limits *lim;
   int i;
-  UINT16 sa[4], sb[4];
 #endif /* !VMS */
 
 #ifdef VMS
@@ -434,9 +404,7 @@ shipit:
 }
 
 void
-encode_double( pBuf, fp )
+encode_double( BUF* pBuf, double* fp )
-    BUF* pBuf;
-    double* fp;
 {
   bencode_double( &(pBuf->buf[pBuf->pos]), fp );
   pBuf->pos += 8;
@@ -444,16 +412,13 @@ encode_double( pBuf, fp )
 }
 
 void
-bdecode_double( buf, dp )
+bdecode_double( char* buf, double* dp )
-    char* buf;
-    double* dp;
 {
 #ifndef VMS
-  struct ieee_double id, *idp;
+  struct ieee_double *idp;
   struct vax_double vd;
   register struct dbl_limits *lim;
   int i;
-  UINT16 sa[4], sb[4];
 #endif /* !VMS */
 
 #ifdef VMS
@@ -486,9 +451,7 @@ shipit:
 }
 
 void
-decode_double( pBuf, fp )
+decode_double( BUF* pBuf, double* fp )
-    BUF* pBuf;
-    double* fp;
 {
   bdecode_double( &(pBuf->buf[pBuf->pos]), fp );
   pBuf->pos += 8;

src/external/mud/src/mud_gen.c

@@ -30,7 +30,7 @@
 #include <math.h>
 #include "mud.h"
 
-/* #define DEBUG 1 /*  (un)comment for debug */  
+/* #define DEBUG 1 */ /*  (un)comment for debug */  
 #define PACK_OP 1
 #define UNPACK_OP 2
 static int pack_op;
@@ -42,15 +42,11 @@ static void next_few_bins _ANSI_ARGS_(( int num_tot, int inBinSize, void* pHistD
 
 
 int
-MUD_SEC_GEN_RUN_DESC_proc( op, pBuf, pMUD )
+MUD_SEC_GEN_RUN_DESC_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_RUN_DESC* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_GEN_RUN_DESC* pMUD;
 {
     int size;
     char tempStr1[32];
     char tempStr2[32];
-    int  imin,isec;
     time_t bintime;
 
     switch( op )
@@ -124,16 +120,16 @@ MUD_SEC_GEN_RUN_DESC_proc( op, pBuf, pMUD )
 	    return( size );
 	case MUD_SHOW:
 	    printf( "  MUD_SEC_GEN_RUN_DESC: expt:[%ld], run:[%ld]\n",
-			pMUD->exptNumber, pMUD->runNumber );
+                    (long)(pMUD->exptNumber), (long)(pMUD->runNumber) );
 	    bintime = pMUD->timeBegin;
 	    strncpy( tempStr1, ctime( &bintime ), sizeof(tempStr1) );
 	    tempStr1[strlen(tempStr1)-1] = '\0';
 	    bintime = pMUD->timeEnd;
 	    strncpy( tempStr2, ctime( &bintime ), sizeof(tempStr2) );
 	    tempStr2[strlen(tempStr2)-1] = '\0';
-	    printf( "    timeBegin:[%s] [%ld]\n", tempStr1, pMUD->timeBegin );
+	    printf( "    timeBegin:[%s] [%lu]\n", tempStr1, (unsigned long)(pMUD->timeBegin) );
-	    printf( "    timeEnd:[%s] [%ld]\n", tempStr2, pMUD->timeEnd );
+	    printf( "    timeEnd:[%s] [%lu]\n", tempStr2, (unsigned long)(pMUD->timeEnd) );
-	    printf( "    elapsedSec:[%ld]\n", pMUD->elapsedSec );
+	    printf( "    elapsedSec:[%ld]\n", (long)(pMUD->elapsedSec) );
 	    if( pMUD->title ) printf( "    title:\"%s\"\n", pMUD->title );
 	    if( pMUD->lab ) printf( "    lab:\"%s\"\n", pMUD->lab );
 	    if( pMUD->area ) printf( "    area:\"%s\"\n", pMUD->area );
@@ -152,8 +148,8 @@ MUD_SEC_GEN_RUN_DESC_proc( op, pBuf, pMUD )
 		printf( "    field:\"%s\"\n", pMUD->field );
 	    break;
 	case MUD_HEADS:
-	    printf( "Run number:    %ld\n", pMUD->runNumber );
+            printf( "Run number:    %ld\n", (long)(pMUD->runNumber) );
-	    printf( "  exper num:   %ld\n", pMUD->exptNumber );
+            printf( "  exper num:   %ld\n", (long)(pMUD->exptNumber) );
 	    if( pMUD->experimenter ) 
 	        printf( "  operator:    %s\n", pMUD->experimenter );
 	    if( pMUD->method ) printf( "  method:      %s\n", pMUD->method );
@@ -165,9 +161,9 @@ MUD_SEC_GEN_RUN_DESC_proc( op, pBuf, pMUD )
 	    tempStr2[strlen(tempStr2)-1] = '\0';
 	    printf( "  began:       %s\n  ended:       %s\n",
                     tempStr1, tempStr2 );
-            printf( "  elapsed:     %ld:%.2d:%.2d   (%ld seconds)\n",
+            printf( "  elapsed:     %ld:%.2d:%.2d   (%lu seconds)\n",
-                     (pMUD->elapsedSec/3600), ((pMUD->elapsedSec%3600)/60), (pMUD->elapsedSec%60),
+                    (long)(pMUD->elapsedSec/3600), ((pMUD->elapsedSec%3600)/60), (pMUD->elapsedSec%60),
-                     pMUD->elapsedSec );
+                    (unsigned long)(pMUD->elapsedSec) );
             if( pMUD->title )  
             {
                 if( strlen( pMUD->title ) > 63 && strlen( pMUD->title ) < 80 )
@@ -197,10 +193,7 @@ MUD_SEC_GEN_RUN_DESC_proc( op, pBuf, pMUD )
 
 
 int
-MUD_SEC_GEN_HIST_HDR_proc( op, pBuf, pMUD )
+MUD_SEC_GEN_HIST_HDR_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_HIST_HDR* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_GEN_HIST_HDR* pMUD;
 {
     int size;
     UINT32 fsBin;
@@ -246,28 +239,28 @@ MUD_SEC_GEN_HIST_HDR_proc( op, pBuf, pMUD )
 	    size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->title );
 	    return( size );
 	case MUD_SHOW:
-	    printf( "  MUD_SEC_GEN_HIST_HDR: histType:[0x%08lX]\n", pMUD->histType );
+            printf( "  MUD_SEC_GEN_HIST_HDR: histType:[0x%08lX]\n", (unsigned long)(pMUD->histType) );
-	    printf( "    nBytes:[%ld], nBins:[%ld], nEvents:[%ld]\n", 
+	    printf( "    nBytes:[%ld], nBins:[%ld], nEvents:[%lu]\n", 
-			pMUD->nBytes, pMUD->nBins, pMUD->nEvents );
+                    (long)(pMUD->nBytes), (long)(pMUD->nBins), (unsigned long)(pMUD->nEvents) );
 	    printf( "    bytesPerBin:[%ld], fsPerBin:[%ld], t0_ps:[%ld], t0_bin:[%ld]\n", 
-			pMUD->bytesPerBin, pMUD->fsPerBin, pMUD->t0_ps, pMUD->t0_bin );
+                    (long)(pMUD->bytesPerBin), (long)(pMUD->fsPerBin), (long)(pMUD->t0_ps), (long)(pMUD->t0_bin) );
 	    printf( "    goodBin1:[%ld], goodBin2:[%ld], bkgd1:[%ld], bkgd2:[%ld]\n", 
-			pMUD->goodBin1, pMUD->goodBin2, pMUD->bkgd1, pMUD->bkgd2 );
+                    (long)(pMUD->goodBin1), (long)(pMUD->goodBin2), (long)(pMUD->bkgd1), (long)(pMUD->bkgd2) );
 	    if( pMUD->title ) printf( "    title:\"%s\"\n", pMUD->title );
 	    break;
 	case MUD_HEADS:
 	    if( pMUD->title ) printf( "Hist title: %s\n", pMUD->title );
-	    printf( "  nBins: %ld,  nEvents: %ld,  ",
+	    printf( "  nBins: %ld,  nEvents: %lu,  ",
-			pMUD->nBins, pMUD->nEvents );
+                    (long)(pMUD->nBins), (unsigned long)(pMUD->nEvents) );
 	    fsBin = pMUD->fsPerBin;
 	    if( fsBin < 16 )
 	    {
 		nsBin = 0.078125 * pow( (double)2.0, (double)fsBin );
-		printf( "ns_per_Bin: %.lf\n", nsBin );
+		printf( "ns_per_Bin: %.6lf\n", nsBin );
 	    }
 	    else if( fsBin < 29 )
 	    {
-		nsBin = 0.048828125 * pow( (double)2.0, (double)fsBin - 16 );
+                nsBin = 0.048828125 * pow( (double)2.0, (double)(fsBin - 16) );
 		printf( "ns_per_Bin: %.9lf\n", nsBin );
 	    }
 	    else
@@ -277,9 +270,9 @@ MUD_SEC_GEN_HIST_HDR_proc( op, pBuf, pMUD )
 	    }
 
 	    printf( "  t0_ps: %ld,  t0_bin: %ld\n", 
-			pMUD->t0_ps, pMUD->t0_bin );
+                    (long)(pMUD->t0_ps), (long)(pMUD->t0_bin) );
 	    printf( "  goodBin1: %ld,  goodBin2: %ld,  bkgd1: %ld,  bkgd2: %ld\n", 
-			pMUD->goodBin1, pMUD->goodBin2, pMUD->bkgd1, pMUD->bkgd2 );
+                    (long)(pMUD->goodBin1), (long)(pMUD->goodBin2), (long)(pMUD->bkgd1), (long)(pMUD->bkgd2) );
 	    break;
     }
     return( 1 );
@@ -287,10 +280,7 @@ MUD_SEC_GEN_HIST_HDR_proc( op, pBuf, pMUD )
 
 
 int
-MUD_SEC_GEN_HIST_DAT_proc( op, pBuf, pMUD )
+MUD_SEC_GEN_HIST_DAT_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_HIST_DAT* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_GEN_HIST_DAT* pMUD;
 {
     int size;
 
@@ -313,7 +303,7 @@ MUD_SEC_GEN_HIST_DAT_proc( op, pBuf, pMUD )
 	    size += pMUD->nBytes;
 	    return( size );
 	case MUD_SHOW:
-	    printf( "  MUD_SEC_GEN_HIST_DAT: nBytes:[%ld]\n", pMUD->nBytes );
+          printf( "  MUD_SEC_GEN_HIST_DAT: nBytes:[%ld]\n", (long)(pMUD->nBytes) );
 	    break;
 	case MUD_HEADS:
 	    break;
@@ -323,10 +313,7 @@ MUD_SEC_GEN_HIST_DAT_proc( op, pBuf, pMUD )
 
 
 int 
-MUD_SEC_GEN_SCALER_proc( op, pBuf, pMUD )
+MUD_SEC_GEN_SCALER_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_SCALER* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_GEN_SCALER* pMUD;
 {
     int size;
 
@@ -350,15 +337,16 @@ MUD_SEC_GEN_SCALER_proc( op, pBuf, pMUD )
 	    size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->label );
 	    return( size );
 	case MUD_SHOW:
-	    printf( "  MUD_SEC_GEN_SCALER: counts[1]:[%ld], counts[0]:[%ld]\n",
+	    printf( "  MUD_SEC_GEN_SCALER: counts[1]:[%lu], counts[0]:[%lu]\n",
-			pMUD->counts[1], pMUD->counts[0] );
+                    (unsigned long)(pMUD->counts[1]), (unsigned long)(pMUD->counts[0]) );
 	    if( pMUD->label ) printf( "    label:\"%s\"\n", pMUD->label );
 	    break;
 	case MUD_HEADS:
 	    printf( "  Scaler " );
 	    if( pMUD->label ) printf( "%8s", pMUD->label );
 	    else  printf( "???     " );
-	    printf( "  total: %11ld,  recent: %ld\n", pMUD->counts[0], pMUD->counts[1] );
+	    printf( "  total: %11lu,  recent: %lu\n", 
+                    (unsigned long)(pMUD->counts[0]), (unsigned long)(pMUD->counts[1]) );
 	    break;
     }
     return( 1 );
@@ -366,10 +354,7 @@ MUD_SEC_GEN_SCALER_proc( op, pBuf, pMUD )
 
 
 int
-MUD_SEC_GEN_IND_VAR_proc( op, pBuf, pMUD )
+MUD_SEC_GEN_IND_VAR_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_IND_VAR* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_GEN_IND_VAR* pMUD;
 {
     int size;
 
@@ -431,10 +416,7 @@ MUD_SEC_GEN_IND_VAR_proc( op, pBuf, pMUD )
 
 
 int 
-MUD_SEC_GEN_ARRAY_proc( op, pBuf, pMUD )
+MUD_SEC_GEN_ARRAY_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_GEN_ARRAY* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_GEN_ARRAY* pMUD;
 {
     int size;
     int i;
@@ -538,8 +520,8 @@ MUD_SEC_GEN_ARRAY_proc( op, pBuf, pMUD )
 	case MUD_SHOW:
 	    printf( "  MUD_SEC_GEN_ARRAY: \n" );
 	    printf( "    num:[%ld], elemSize:[%ld], type:[%ld], hasTime:[%ld], nBytes:[%ld]\n", 
-                    pMUD->num, pMUD->elemSize, pMUD->type, pMUD->hasTime,
+                    (long)(pMUD->num), (long)(pMUD->elemSize), (long)(pMUD->type), (long)(pMUD->hasTime),
-                    pMUD->nBytes );
+                    (long)(pMUD->nBytes) );
 	    break;
 	case MUD_HEADS:
 	    break;
@@ -549,42 +531,27 @@ MUD_SEC_GEN_ARRAY_proc( op, pBuf, pMUD )
 
 
 int
-MUD_SEC_GEN_HIST_pack( num, inBinSize, inHist, outBinSize, outHist )
+MUD_SEC_GEN_HIST_pack( int num, int inBinSize, void* inHist, int outBinSize, void* outHist )
-    int num;
-    int inBinSize;
-    void* inHist;
-    int outBinSize;
-    void* outHist;
 {
   pack_op = PACK_OP;
   return( MUD_SEC_GEN_HIST_dopack( num, inBinSize, inHist, outBinSize, outHist ) );
 }
 
 int
-MUD_SEC_GEN_HIST_unpack( num, inBinSize, inHist, outBinSize, outHist )
+MUD_SEC_GEN_HIST_unpack( int num, int inBinSize, void* inHist, int outBinSize, void* outHist )
-    int num;
-    int inBinSize;
-    void* inHist;
-    int outBinSize;
-    void* outHist;
 {
   pack_op = UNPACK_OP;
   return( MUD_SEC_GEN_HIST_dopack( num, inBinSize, inHist, outBinSize, outHist ) );
 }
 
 static int
-MUD_SEC_GEN_HIST_dopack( num, inBinSize, inHist, outBinSize, outHist )
+MUD_SEC_GEN_HIST_dopack( int num, int inBinSize, void* inHist, int outBinSize, void* outHist )
-    int num;
-    int inBinSize;
-    void* inHist;
-    int outBinSize;
-    void* outHist;
 {
     int i;
     int outLen = 0;
     MUD_VAR_BIN_LEN_TYPE num_temp;
     int bin, inLoc, outLoc;
-    int inLen_temp, outLen_temp;
+    int outLen_temp;
     MUD_VAR_BIN_SIZ_TYPE outBinSize_now, outBinSize_next;
     MUD_VAR_BIN_SIZ_TYPE inBinSize_temp;
     UINT8  c, *pc;
@@ -935,8 +902,7 @@ MUD_SEC_GEN_HIST_dopack( num, inBinSize, inHist, outBinSize, outHist )
 
 
 static int
-n_bytes_needed( val )
+n_bytes_needed( UINT32 val )
-    UINT32 val;
 {
     if( val & 0xFFFF0000 ) return( 4 );
     else if( val & 0x0000FF00 ) return( 2 );
@@ -946,10 +912,7 @@ n_bytes_needed( val )
 
 
 static UINT32
-varBinArray( pHistData, binSize, index )
+varBinArray( void* pHistData, int binSize, int index )
-    void* pHistData;
-    int binSize;
-    int index;
 {
   UINT8  c;
   UINT16 s;
@@ -991,17 +954,8 @@ varBinArray( pHistData, binSize, index )
 
 
 static void
-next_few_bins( num_tot, inBinSize, 
+next_few_bins( int num_tot, int inBinSize, void* pHistData, int outBinSize_now,
-	       pHistData, 
+               MUD_VAR_BIN_LEN_TYPE* pNum_next, MUD_VAR_BIN_SIZ_TYPE* pOutBinSize_next )
-	       outBinSize_now, 
-	       pNum_next, 
-	       pOutBinSize_next )
-    int num_tot;
-    int inBinSize;
-    void* pHistData;
-    int outBinSize_now;
-    MUD_VAR_BIN_LEN_TYPE* pNum_next;
-    MUD_VAR_BIN_SIZ_TYPE* pOutBinSize_next;
 {
     int val;
     MUD_VAR_BIN_LEN_TYPE num_next;

src/external/mud/src/mud_new.c

@@ -27,13 +27,11 @@
  *   v1.2a  01-Mar-2000  DA   Add handling of unidentified sections (don't quit)
  */
 
+
 #include "mud.h"
 
-
 MUD_SEC*
-MUD_new( secID, instanceID )
+MUD_new( UINT32 secID, UINT32 instanceID )
-    UINT32 secID;
-    UINT32 instanceID;
 {
     MUD_SEC* pMUD_new;
     MUD_PROC proc;
@@ -43,78 +41,78 @@ MUD_new( secID, instanceID )
     {
 	case MUD_SEC_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC ) );
-	    proc = MUD_SEC_proc;
+	    proc = (MUD_PROC)MUD_SEC_proc;
 	    sizeOf = sizeof( MUD_SEC );
 	    break;
 	case MUD_SEC_FIXED_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_FIXED ) );
-	    proc = MUD_SEC_FIXED_proc;
+	    proc = (MUD_PROC)MUD_SEC_FIXED_proc;
 	    sizeOf = sizeof( MUD_SEC_FIXED );
 	    break;
 	case MUD_SEC_GRP_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_GRP ) );
-	    proc = MUD_SEC_GRP_proc;
+	    proc = (MUD_PROC)MUD_SEC_GRP_proc;
 	    sizeOf = sizeof( MUD_SEC_GRP );
 	    break;
 	case MUD_SEC_EOF_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_EOF ) );
-	    proc = MUD_SEC_EOF_proc;
+	    proc = (MUD_PROC)MUD_SEC_EOF_proc;
 	    sizeOf = sizeof( MUD_SEC_EOF );
 	    break;
 	case MUD_SEC_CMT_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_CMT ) );
-	    proc = MUD_SEC_CMT_proc;
+	    proc = (MUD_PROC)MUD_SEC_CMT_proc;
 	    sizeOf = sizeof( MUD_SEC_CMT );
 	    break;
 	case MUD_SEC_GEN_RUN_DESC_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_GEN_RUN_DESC ) );
-	    proc = MUD_SEC_GEN_RUN_DESC_proc;
+	    proc = (MUD_PROC)MUD_SEC_GEN_RUN_DESC_proc;
 	    sizeOf = sizeof( MUD_SEC_GEN_RUN_DESC );
 	    break;
 	case MUD_SEC_GEN_HIST_HDR_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_GEN_HIST_HDR ) );
-	    proc = MUD_SEC_GEN_HIST_HDR_proc;
+	    proc = (MUD_PROC)MUD_SEC_GEN_HIST_HDR_proc;
 	    sizeOf = sizeof( MUD_SEC_GEN_HIST_HDR );
 	    break;
 	case MUD_SEC_GEN_HIST_DAT_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_GEN_HIST_DAT ) );
-	    proc = MUD_SEC_GEN_HIST_DAT_proc;
+	    proc = (MUD_PROC)MUD_SEC_GEN_HIST_DAT_proc;
 	    sizeOf = sizeof( MUD_SEC_GEN_HIST_DAT );
 	    break;
 	case MUD_SEC_GEN_SCALER_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_GEN_SCALER ) );
-	    proc = MUD_SEC_GEN_SCALER_proc;
+	    proc = (MUD_PROC)MUD_SEC_GEN_SCALER_proc;
 	    sizeOf = sizeof( MUD_SEC_GEN_SCALER );
 	    break;
 	case MUD_SEC_GEN_IND_VAR_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_GEN_IND_VAR ) );
-	    proc = MUD_SEC_GEN_IND_VAR_proc;
+	    proc = (MUD_PROC)MUD_SEC_GEN_IND_VAR_proc;
 	    sizeOf = sizeof( MUD_SEC_GEN_IND_VAR );
 	    break;
 	case MUD_SEC_GEN_ARRAY_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_GEN_ARRAY ) );
-	    proc = MUD_SEC_GEN_ARRAY_proc;
+	    proc = (MUD_PROC)MUD_SEC_GEN_ARRAY_proc;
 	    sizeOf = sizeof( MUD_SEC_GEN_ARRAY );
 	    break;
 	case MUD_SEC_TRI_TI_RUN_DESC_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_TRI_TI_RUN_DESC ) );
-	    proc = MUD_SEC_TRI_TI_RUN_DESC_proc;
+	    proc = (MUD_PROC)MUD_SEC_TRI_TI_RUN_DESC_proc;
 	    sizeOf = sizeof( MUD_SEC_TRI_TI_RUN_DESC );
 	    break;
 /*
 	case MUD_SEC_CAMP_NUM_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_CAMP_NUM ) );
-	    proc = MUD_SEC_CAMP_NUM_proc;
+	    proc = (MUD_PROC)MUD_SEC_CAMP_NUM_proc;
 	    sizeOf = sizeof( MUD_SEC_CAMP_NUM );
 	    break;
 	case MUD_SEC_CAMP_STR_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_CAMP_STR ) );
-	    proc = MUD_SEC_CAMP_STR_proc;
+	    proc = (MUD_PROC)MUD_SEC_CAMP_STR_proc;
 	    sizeOf = sizeof( MUD_SEC_CAMP_STR );
 	    break;
 	case MUD_SEC_CAMP_SEL_ID:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_CAMP_SEL ) );
-	    proc = MUD_SEC_CAMP_SEL_proc;
+	    proc = (MUD_PROC)MUD_SEC_CAMP_SEL_proc;
 	    sizeOf = sizeof( MUD_SEC_CAMP_SEL );
 	    break;
 */
@@ -122,7 +120,7 @@ MUD_new( secID, instanceID )
 /* add action for unknown */
 	default:
 	    pMUD_new = (MUD_SEC*)zalloc( sizeof( MUD_SEC_UNKNOWN ) );
-	    proc = MUD_SEC_UNKNOWN_proc;
+	    proc = (MUD_PROC)MUD_SEC_UNKNOWN_proc;
 	    sizeOf = sizeof( MUD_SEC_UNKNOWN );
 	    break;
 
@@ -138,4 +136,3 @@ MUD_new( secID, instanceID )
     return( pMUD_new );
 }
 
-

src/external/mud/src/mud_tri_ti.c

@@ -27,10 +27,7 @@
 
 
 int
-MUD_SEC_TRI_TI_RUN_DESC_proc( op, pBuf, pMUD )
+MUD_SEC_TRI_TI_RUN_DESC_proc( MUD_OPT op, BUF* pBuf, MUD_SEC_TRI_TI_RUN_DESC* pMUD )
-    MUD_OPT op;
-    BUF* pBuf;
-    MUD_SEC_TRI_TI_RUN_DESC* pMUD;
 {
     int size;
     char tempStr1[32];
@@ -115,8 +112,8 @@ MUD_SEC_TRI_TI_RUN_DESC_proc( op, pBuf, pMUD )
 	    size += sizeof( MUD_STR_LEN_TYPE ) + _strlen( pMUD->comment3 );
 	    return( size );
 	case MUD_SHOW:
-	    printf( "  MUD_SEC_TRI_TI_RUN_DESC: expt:[%ld], run:[%ld]\n",
+	    printf( "  MUD_SEC_TRI_TI_RUN_DESC: expt:[%lu], run:[%lu]\n",
-			pMUD->exptNumber, pMUD->runNumber );
+                    (unsigned long)(pMUD->exptNumber), (unsigned long)(pMUD->runNumber) );
 	    bintime = pMUD->timeBegin;
 	    strncpy( tempStr1, ctime( &bintime ), sizeof(tempStr1) );
 	    tempStr1[strlen(tempStr1)-1] = '\0';
@@ -125,7 +122,7 @@ MUD_SEC_TRI_TI_RUN_DESC_proc( op, pBuf, pMUD )
 	    tempStr2[strlen(tempStr2)-1] = '\0';
 	    printf( "    timeBegin:[%s]\n", tempStr1 );
 	    printf( "    timeEnd:[%s]\n", tempStr2 );
-	    printf( "    elapsedSec:[%ld]\n", pMUD->elapsedSec );
+	    printf( "    elapsedSec:[%lu]\n", (unsigned long)(pMUD->elapsedSec) );
 	    if( pMUD->title ) printf( "    title:\"%s\"\n", pMUD->title );
 	    if( pMUD->lab ) printf( "    lab:\"%s\"\n", pMUD->lab );
 	    if( pMUD->area ) printf( "    area:\"%s\"\n", pMUD->area );
@@ -148,8 +145,8 @@ MUD_SEC_TRI_TI_RUN_DESC_proc( op, pBuf, pMUD )
 		printf( "    comment3:\"%s\"\n", pMUD->comment3 );
 	    break;
 	case MUD_HEADS:
-	    printf( "Run number:     %ld\n", pMUD->runNumber );
+            printf( "Run number:     %lu\n", (unsigned long)(pMUD->runNumber) );
-	    printf( "  exper num:    %ld\n", pMUD->exptNumber );
+            printf( "  exper num:    %lu\n", (unsigned long)(pMUD->exptNumber) );
 	    if( pMUD->experimenter ) 
 	        printf( "  operator:     %s\n", pMUD->experimenter );
             if( pMUD->method ) 
@@ -162,9 +159,9 @@ MUD_SEC_TRI_TI_RUN_DESC_proc( op, pBuf, pMUD )
 	    tempStr2[strlen(tempStr2)-1] = '\0';
 	    printf( "  began:        %s\n  ended:        %s\n",
                      tempStr1, tempStr2 );
-            printf( "  elapsed:      %ld:%.2d:%.2d   (%ld seconds)\n",
+            printf( "  elapsed:      %ld:%.2d:%.2d   (%lu seconds)\n",
-                     (pMUD->elapsedSec/3600), ((pMUD->elapsedSec%3600)/60), (pMUD->elapsedSec%60), 
+                    (long)(pMUD->elapsedSec/3600), ((pMUD->elapsedSec%3600)/60), (pMUD->elapsedSec%60), 
-                      pMUD->elapsedSec );
+                    (unsigned long)(pMUD->elapsedSec) );
 	    if( pMUD->title )  printf( "  title:        %s\n", pMUD->title );
 	    if( pMUD->sample ) printf( "  sample:       %s\n", pMUD->sample );
 	    if( pMUD->orient ) printf( "  orient:       %s\n", pMUD->orient );

src/external/nexus/PNeXus.cpp

@@ -818,10 +818,10 @@ PNeXusDetector2::PNeXusDetector2()
   fNoOfBins = -1;
 
   fT0Tag = -1;
-  fT0 = 0;
+  fT0 = nullptr;
-  fFirstGoodBin = 0;
+  fFirstGoodBin = nullptr;
-  fLastGoodBin = 0;
+  fLastGoodBin = nullptr;
-  fHisto = 0;
+  fHisto = nullptr;
 }
 
 //------------------------------------------------------------------------------------------
@@ -837,19 +837,19 @@ PNeXusDetector2::~PNeXusDetector2()
 
   if (fT0) {
     delete [] fT0;
-    fT0 = 0;
+    fT0 = nullptr;
   }
   if (fFirstGoodBin) {
     delete [] fFirstGoodBin;
-    fFirstGoodBin = 0;
+    fFirstGoodBin = nullptr;
   }
   if (fLastGoodBin) {
     delete [] fLastGoodBin;
-    fLastGoodBin = 0;
+    fLastGoodBin = nullptr;
   }
   if (fHisto) {
     delete [] fHisto;
-    fHisto = 0;
+    fHisto = nullptr;
   }
 }
 
@@ -919,10 +919,16 @@ bool PNeXusDetector2::IsValid(bool strict)
  */
 int PNeXusDetector2::GetT0(int idxp, int idxs)
 {
-  int result = -1;
+  int result = -1;  
+
+  if (fT0Tag == 1) { // there is only ONE t0 present
+    if (fT0 != nullptr)
+      result = *fT0;
+    return result;
+  }
 
   if ((idxp < 0) && (idxs < 0)) { // assumption: there is only ONE t0 for all spectra
-    if (fT0 != 0) {
+    if (fT0 != nullptr) {
       result = *fT0;
     }
   } else if ((idxp < 0) && (idxs >= 0)) { // assumption: t0's are represented as t0[ns]
@@ -1031,17 +1037,24 @@ int PNeXusDetector2::GetFirstGoodBin(int idxp, int idxs)
 {
   int result = -1;
 
+  if (fT0Tag == 1) { // there is only ONE t0 present
+    if (fT0 != nullptr)
+      result = *fFirstGoodBin;
+    return result;
+  }
+
   if ((idxp < 0) && (idxs < 0)) { // assumption: there is only ONE t0 for all spectra
-    if (fFirstGoodBin != 0) {
+    if (fFirstGoodBin != nullptr) {
       result = *fFirstGoodBin;
     }
   } else if ((idxp < 0) && (idxs >= 0)) { // assumptions: fgb's are represented as fgb[ns]
-    if (idxs < fNoOfSpectra) {
+    if ((idxs < fNoOfSpectra) && (fFirstGoodBin != nullptr)) {
       result = *(fFirstGoodBin+idxs);
     }
   } else if ((idxp >= 0) && (idxs >= 0)) { // assumption: fgb's are represented as fgb[np][ns]
     if ((idxp < fNoOfPeriods) || (idxs < fNoOfSpectra)) {
-      result = *(fFirstGoodBin+idxp*fNoOfSpectra+idxs);
+      if (fFirstGoodBin != nullptr)
+        result = *(fFirstGoodBin+idxp*fNoOfSpectra+idxs);
     }
   } else {
     result = -1;
@@ -1141,17 +1154,24 @@ int PNeXusDetector2::GetLastGoodBin(int idxp, int idxs)
 {
   int result = -1;
 
+  if (fT0Tag == 1) { // there is only ONE t0 present
+    if (fT0 != nullptr)
+      result = *fLastGoodBin;
+    return result;
+  }
+
   if ((idxp < 0) && (idxs < 0)) { // assumption: there is only ONE t0 for all spectra
-    if (fLastGoodBin != 0) {
+    if (fLastGoodBin != nullptr) {
       result = *fLastGoodBin;
     }
   } else if ((idxp < 0) && (idxs >= 0)) { // assumption: lgb's are represented as lgb[ns]
-    if (idxs < fNoOfSpectra) {
+    if ((idxs < fNoOfSpectra) && (fLastGoodBin != nullptr)) {
       result = *(fLastGoodBin+idxs);
     }
   } else if ((idxp >= 0) && (idxs >= 0)) { // assumption: lgb's are represented as lgb[np][ns]
     if ((idxp < fNoOfPeriods) || (idxs < fNoOfSpectra)) {
-      result = *(fLastGoodBin+idxp*fNoOfSpectra+idxs);
+      if (fLastGoodBin != nullptr)
+        result = *(fLastGoodBin+idxp*fNoOfSpectra+idxs);
     }
   } else {
     result = -1;
@@ -3398,6 +3418,14 @@ int PNeXus::ReadFileIdf2()
     return NX_ERROR;
   }
 
+  // beamline
+  if (SearchInGroup("beamline", "name", nxname, nxclass, dataType)) {
+    if (!ErrorHandler(NXopendata(fFileHandle, "beamline"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'beamline' data in NXentry!")) return NX_ERROR;
+    if (!ErrorHandler(GetStringData(str), PNEXUS_GET_DATA_ERROR, "couldn't read 'beamline' data in NXentry!")) return NX_ERROR;
+    if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'beamline' data in NXentry!")) return NX_ERROR;
+    fNxEntry2->GetInstrument()->GetBeamline()->SetName(str);
+  }
+
   // definition
   if (!ErrorHandler(NXopendata(fFileHandle, "definition"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'definition' data in NXentry!")) return NX_ERROR;
   if (!ErrorHandler(GetStringData(str), PNEXUS_GET_DATA_ERROR, "couldn't read 'definition' data in NXentry!")) return NX_ERROR;
@@ -3576,26 +3604,37 @@ int PNeXus::ReadFileIdf2()
   // close group NXsource
   NXclosegroup(fFileHandle);
 
+
   // open group NXbeamline
-  if (!ErrorHandler(NXopengroup(fFileHandle, "beamline", "NXbeamline"), PNEXUS_GROUP_OPEN_ERROR, "couldn't open NeXus subgroup beamline in NXinstrument!")) return NX_ERROR;
+  if (SearchInGroup("beamline", "name", nxname, nxclass, dataType)) {
+    if (!ErrorHandler(NXopengroup(fFileHandle, "beamline", "NXbeamline"), PNEXUS_GROUP_OPEN_ERROR, "couldn't open NeXus subgroup beamline in NXinstrument!")) return NX_ERROR;
 
-  // beamline name
+    // beamline name
-  if (!ErrorHandler(NXopendata(fFileHandle, "beamline"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'beamline' data in NXbeamline!")) return NX_ERROR;
+    if (!ErrorHandler(NXopendata(fFileHandle, "beamline"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'beamline' data in NXbeamline!")) return NX_ERROR;
-  if (!ErrorHandler(GetStringData(str), PNEXUS_GET_DATA_ERROR, "couldn't read 'beamline' data in NXbeamline!")) return NX_ERROR;
+    if (!ErrorHandler(GetStringData(str), PNEXUS_GET_DATA_ERROR, "couldn't read 'beamline' data in NXbeamline!")) return NX_ERROR;
-  if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'beamline' data in NXbeamline!")) return NX_ERROR;
+    if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'beamline' data in NXbeamline!")) return NX_ERROR;
-  fNxEntry2->GetInstrument()->GetBeamline()->SetName(str);
+    fNxEntry2->GetInstrument()->GetBeamline()->SetName(str);
 
-  // close group NXbeamline
+    // close group NXbeamline
-  NXclosegroup(fFileHandle);
+    NXclosegroup(fFileHandle);
+  } else {
+    std::cerr << "**WARNING** in class NXinstrument the object NXbeamline with name 'beamline' is missing!" << std::endl;
+    std::cerr << "            Complain at the facility where you got this data file from!" << std::endl;
+  }
 
-  // open group NXdetector
+  // open group NXdetector in instrument (NXinstrument)
   if (!ErrorHandler(NXopengroup(fFileHandle, "detector_1", "NXdetector"), PNEXUS_GROUP_OPEN_ERROR, "couldn't open NeXus subgroup detector_1 in NXinstrument!")) return NX_ERROR;
 
   // description
-  if (!ErrorHandler(NXopendata(fFileHandle, "description"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'description' data in NXdetector!")) return NX_ERROR;
+  if (SearchInGroup("description", "name", nxname, nxclass, dataType)) {
-  if (!ErrorHandler(GetStringData(str), PNEXUS_GET_DATA_ERROR, "couldn't read 'description' data in NXdetector!")) return NX_ERROR;
+    if (!ErrorHandler(NXopendata(fFileHandle, "description"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'description' data in NXdetector!")) return NX_ERROR;
-  if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'description' data in NXdetector!")) return NX_ERROR;
+    if (!ErrorHandler(GetStringData(str), PNEXUS_GET_DATA_ERROR, "couldn't read 'description' data in NXdetector!")) return NX_ERROR;
-  fNxEntry2->GetInstrument()->GetDetector()->SetDescription(str);
+    if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'description' data in NXdetector!")) return NX_ERROR;
+    fNxEntry2->GetInstrument()->GetDetector()->SetDescription(str);
+  } else {
+    std::cerr << "**WARNING** in class NXdetector to object NX_CHAR with name 'description' is missing!" << std::endl;
+    std::cerr << "            Complain at the facility where you got this data file from!" << std::endl;
+  }
 
   // get the time resolution. This is a little bit complicated since it is either present as 'histogram_resolution' or needs to be extracted from the 'raw_time' vector
   // 1st check if 'histogram_resolution' is found
@@ -3607,10 +3646,10 @@ int PNeXus::ReadFileIdf2()
     fNxEntry2->GetInstrument()->GetDetector()->SetTimeResolution((double)fval, str);
   } else if (SearchInGroup("resolution", "name", nxname, nxclass, dataType)) { // 2nd check if 'resolution' is found
     if (!ErrorHandler(NXopendata(fFileHandle, "resolution"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'resolution' data in NXdetector!")) return NX_ERROR;
-    if (!ErrorHandler(NXgetdata(fFileHandle, &fval), PNEXUS_GET_DATA_ERROR, "couldn't read 'resolution' data in NXdetector!")) return NX_ERROR;
+    if (!ErrorHandler(NXgetdata(fFileHandle, &ival), PNEXUS_GET_DATA_ERROR, "couldn't read 'resolution' data in NXdetector!")) return NX_ERROR;
     if (!ErrorHandler(GetStringAttr("units", str), PNEXUS_GET_ATTR_ERROR, "couldn't read time resolution units in NXdetector!")) return NX_ERROR;
     if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'resolution' data in NXdetector!")) return NX_ERROR;
-    fNxEntry2->GetInstrument()->GetDetector()->SetTimeResolution((double)fval, str);
+    fNxEntry2->GetInstrument()->GetDetector()->SetTimeResolution((double)ival, str);
   } else { // 3nd 'histogram_resolution' is not present, hence extract the time resolution from the 'raw_time' vector
     if (!ErrorHandler(NXopendata(fFileHandle, "raw_time"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'raw_time' data in NXdetector!")) return NX_ERROR;
     std::vector<double> rawTime;
@@ -3626,6 +3665,51 @@ int PNeXus::ReadFileIdf2()
   // check the dimensions of 'counts'
   if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'counts' info in NXdetector!")) return NX_ERROR;
 
+  // check if last_good_bin, first_good_bin, and t0_bins are defined as attributes
+  int attLen = 1, attType = NX_INT32;
+  if (SearchAttrInData("first_good_bin", attLen, attType)) {
+    char  cstr[1204];
+    memset(cstr, '\0', sizeof(cstr));
+    strncpy(cstr, "first_good_bin", sizeof(cstr));
+    status = NXgetattr(fFileHandle, cstr, (void*)&ival, &attLen, &attType);
+
+    fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(1); // a single set for t0, fgb, lgb is likely given
+    int *i_data_ptr = new int;
+    *i_data_ptr = ival;
+    if (!fNxEntry2->GetInstrument()->GetDetector()->SetFirstGoodBin(i_data_ptr)) {
+      std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+      return NX_ERROR;
+    }
+  }
+  if (SearchAttrInData("last_good_bin", attLen, attType)) {
+    char  cstr[1204];
+    memset(cstr, '\0', sizeof(cstr));
+    strncpy(cstr, "last_good_bin", sizeof(cstr));
+    status = NXgetattr(fFileHandle, cstr, (void*)&ival, &attLen, &attType);
+
+    fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(1); // a single set for t0, fgb, lgb is likely given
+    int *i_data_ptr = new int;
+    *i_data_ptr = ival;
+    if (!fNxEntry2->GetInstrument()->GetDetector()->SetLastGoodBin(i_data_ptr)) {
+      std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+      return NX_ERROR;
+    }
+  }
+  if (SearchAttrInData("t0_bin", attLen, attType)) {
+    char  cstr[1204];
+    memset(cstr, '\0', sizeof(cstr));
+    strncpy(cstr, "t0_bin", sizeof(cstr));
+    status = NXgetattr(fFileHandle, cstr, (void*)&ival, &attLen, &attType);
+
+    fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(1); // a single set for t0, fgb, lgb is likely given
+    int *i_data_ptr = new int;
+    *i_data_ptr = ival;
+    if (!fNxEntry2->GetInstrument()->GetDetector()->SetT0(i_data_ptr)) {
+      std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+      return NX_ERROR;
+    }
+  }
+
   // calculate the needed size
   size = dims[0];
   for (int i=1; i<rank; i++)
@@ -3713,320 +3797,323 @@ int PNeXus::ReadFileIdf2()
 
   if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'spectrum_index' data in NXdetector!")) return NX_ERROR;
 
-  // handle t0's
+  // only handle t0, fgb, lgb, if they are not already set as an attribute of /raw_data_1/instrument/detector_1/counts
-  if (SearchInGroup("time_zero_bin", "name", nxname, nxclass, dataType)) { // check for 'time_zero_bin'
+  if (fNxEntry2->GetInstrument()->GetDetector()->GetT0Tag() == -1) {
-    if (!ErrorHandler(NXopendata(fFileHandle, "time_zero_bin"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'time_zero_bin' data in NXdetector!")) return NX_ERROR;
+    // handle t0's
+    if (SearchInGroup("time_zero_bin", "name", nxname, nxclass, dataType)) { // check for 'time_zero_bin'
+      if (!ErrorHandler(NXopendata(fFileHandle, "time_zero_bin"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'time_zero_bin' data in NXdetector!")) return NX_ERROR;
 
-    // check the dimensions of the 'time_zero_bin' vector
+      // check the dimensions of the 'time_zero_bin' vector
-    if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'time_zero_bin' info in NXdetector!")) return NX_ERROR;
+      if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'time_zero_bin' info in NXdetector!")) return NX_ERROR;
 
-    if ((rank == 1) && (dims[0] == 1)) { // single t0 entry
+      if ((rank == 1) && (dims[0] == 1)) { // single t0 entry
-      fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(1);
+        fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(1);
-    } else if ((rank == 1) && (dims[0] > 1)) { // t0 of the form t0[ns]
+      } else if ((rank == 1) && (dims[0] > 1)) { // t0 of the form t0[ns]
-      fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(2);
+        fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(2);
-    } else if (rank == 2) { // t0 of the form t0[np][ns]
+      } else if (rank == 2) { // t0 of the form t0[np][ns]
-      fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(3);
+        fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(3);
+      } else {
+        std::cerr << std::endl << ">> **ERROR** found 'time_zero_bin' info in NXdetector with rank=" << rank << ". Do not know how to handle." << std::endl;
+        return NX_ERROR;
+      }
+
+      // calculate the needed size
+      size = dims[0];
+      for (int i=1; i<rank; i++)
+        size *= dims[i];
+      noOfElements = size;
+      size *= GetDataSize(type);
+
+      // allocate locale memory to get the data
+      char *data_ptr = new char[size];
+      if (data_ptr == nullptr) {
+        return NX_ERROR;
+      }
+
+      // get the data
+      int *i_data_ptr = (int*) data_ptr;
+      int status = NXgetdata(fFileHandle, i_data_ptr);
+      if (status != NX_OK) {
+        return NX_ERROR;
+      }
+
+      if (!fNxEntry2->GetInstrument()->GetDetector()->SetT0(i_data_ptr)) {
+        std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+        return NX_ERROR;
+      }
+
+      // clean up
+      if (data_ptr) {
+        delete [] data_ptr;
+        data_ptr = nullptr;
+      }
+
+      if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'time_zero_bin' data in NXdetector!")) return NX_ERROR;
+    } else if (SearchInGroup("time_zero", "name", nxname, nxclass, dataType)) { // check for 'time_zero'
+      if (!ErrorHandler(NXopendata(fFileHandle, "time_zero"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'time_zero' data in NXdetector!")) return NX_ERROR;
+      // check the dimensions of the 'time_zero' vector
+      if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'time_zero' info in NXdetector!")) return NX_ERROR;
+
+      if ((rank == 1) && (dims[0] == 1)) { // single t0 entry
+        fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(1);
+      } else if ((rank == 1) && (dims[0] > 1)) { // t0 of the form t0[ns]
+        fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(2);
+      } else if (rank == 2) { // t0 of the form t0[np][ns]
+        fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(3);
+      } else {
+        std::cerr << std::endl << ">> **ERROR** found 'time_zero' info in NXdetector with rank=" << rank << ". Do not know how to handle." << std::endl;
+        return NX_ERROR;
+      }
+
+      // calculate the needed size
+      size = dims[0];
+      for (int i=1; i<rank; i++)
+        size *= dims[i];
+      noOfElements = size;
+      size *= GetDataSize(type);
+
+      // allocate locale memory to get the data
+      char *data_ptr = new char[size];
+      if (data_ptr == nullptr) {
+        return NX_ERROR;
+      }
+
+      // get the data
+      float *f_data_ptr = (float*) data_ptr;
+      int status = NXgetdata(fFileHandle, f_data_ptr);
+      if (status != NX_OK) {
+        return NX_ERROR;
+      }
+
+      if (!ErrorHandler(GetStringAttr("units", str), PNEXUS_GET_ATTR_ERROR, "couldn't read 'time_zero' units in NXdetector!")) return NX_ERROR;
+
+      // Set T0's
+      // check that the necessary time resolution is present
+      if (fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str) == 0.0) {
+        std::cerr << std::endl << ">> **ERROR** trying to set T0's based on 'time_zero'. Need a valid time resolution to do so, but this is not given." << std::endl;
+        return NX_ERROR;
+      }
+      // set the t0's based on the t0 time stamp and the time resolution
+      int *pt0 = nullptr;
+      if (rank == 1) {
+        pt0 = new int;
+        *pt0 = (int)(*f_data_ptr / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
+      } else { // rank == 2
+        pt0 = new int[noOfElements];
+        for (int i=0; i<noOfElements; i++) {
+          *(pt0+i) = (int)(*(f_data_ptr+i) / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
+        }
+      }
+
+      if (!fNxEntry2->GetInstrument()->GetDetector()->SetT0(pt0)) {
+        std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+        return NX_ERROR;
+      }
+
+      // clean up
+      if (data_ptr) {
+        delete [] data_ptr;
+        data_ptr = nullptr;
+      }
+
+      std::cerr << std::endl << ">> **WARNING** found only 'time_zero' will convert it to 'time_zero_bin' values" << std::endl;
+      if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'time_zero' data in NXdetector!")) return NX_ERROR;
     } else {
-      std::cerr << std::endl << ">> **ERROR** found 'time_zero_bin' info in NXdetector with rank=" << rank << ". Do not know how to handle." << std::endl;
+      std::cerr << std::endl << ">> **WARNING** found neither 'time_zero_bin' nor 'time_zero' values ..." << std::endl;
-      return NX_ERROR;
     }
 
-    // calculate the needed size
+    // handle first good bin
-    size = dims[0];
+    if (SearchInGroup("first_good_bin", "name", nxname, nxclass, dataType)) {
-    for (int i=1; i<rank; i++)
+      if (!ErrorHandler(NXopendata(fFileHandle, "first_good_bin"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'first_good_bin' data in NXdetector!")) return NX_ERROR;
-      size *= dims[i];
-    noOfElements = size;
-    size *= GetDataSize(type);
 
-    // allocate locale memory to get the data
+      // check the dimensions of the 'first_good_bin' vector
-    char *data_ptr = new char[size];
+      if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'first_good_bin' info in NXdetector!")) return NX_ERROR;
-    if (data_ptr == nullptr) {
-      return NX_ERROR;
-    }
 
-    // get the data
+      // calculate the needed size
-    int *i_data_ptr = (int*) data_ptr;
+      size = dims[0];
-    int status = NXgetdata(fFileHandle, i_data_ptr);
+      for (int i=1; i<rank; i++)
-    if (status != NX_OK) {
+        size *= dims[i];
-      return NX_ERROR;
+      noOfElements = size;
-    }
+      size *= GetDataSize(type);
 
-    if (!fNxEntry2->GetInstrument()->GetDetector()->SetT0(i_data_ptr)) {
+      // allocate locale memory to get the data
-      std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+      char *data_ptr = new char[size];
-      return NX_ERROR;
+      if (data_ptr == nullptr) {
-    }
+        return NX_ERROR;
+      }
 
-    // clean up
+      // get the data
-    if (data_ptr) {
+      int *i_data_ptr = (int*) data_ptr;
-      delete [] data_ptr;
+      int status = NXgetdata(fFileHandle, i_data_ptr);
-      data_ptr = nullptr;
+      if (status != NX_OK) {
-    }
+        return NX_ERROR;
+      }
 
-    if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'time_zero_bin' data in NXdetector!")) return NX_ERROR;
+      if (!fNxEntry2->GetInstrument()->GetDetector()->SetFirstGoodBin(i_data_ptr)) {
-  } else if (SearchInGroup("time_zero", "name", nxname, nxclass, dataType)) { // check for 'time_zero'
+        std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
-    if (!ErrorHandler(NXopendata(fFileHandle, "time_zero"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'time_zero' data in NXdetector!")) return NX_ERROR;
+        return NX_ERROR;
-    // check the dimensions of the 'time_zero' vector
+      }
-    if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'time_zero' info in NXdetector!")) return NX_ERROR;
 
-    if ((rank == 1) && (dims[0] == 1)) { // single t0 entry
+      if (data_ptr) {
-      fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(1);
+        delete [] data_ptr;
-    } else if ((rank == 1) && (dims[0] > 1)) { // t0 of the form t0[ns]
+        data_ptr = nullptr;
-      fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(2);
+      }
-    } else if (rank == 2) { // t0 of the form t0[np][ns]
+
-      fNxEntry2->GetInstrument()->GetDetector()->SetT0Tag(3);
+      if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'first_good_bin' data in NXdetector!")) return NX_ERROR;
+    } else if (SearchInGroup("first_good_time", "name", nxname, nxclass, dataType)) {
+      if (!ErrorHandler(NXopendata(fFileHandle, "first_good_time"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'first_good_time' data in NXdetector!")) return NX_ERROR;
+
+      // check the dimensions of the 'first_good_time' vector
+      if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'first_good_time' info in NXdetector!")) return NX_ERROR;
+
+      // calculate the needed size
+      size = dims[0];
+      for (int i=1; i<rank; i++)
+        size *= dims[i];
+      noOfElements = size;
+      size *= GetDataSize(type);
+
+      // allocate locale memory to get the data
+      char *data_ptr = new char[size];
+      if (data_ptr == nullptr) {
+        return NX_ERROR;
+      }
+
+      // get the data
+      float *f_data_ptr = (float*) data_ptr;
+      int status = NXgetdata(fFileHandle, f_data_ptr);
+      if (status != NX_OK) {
+        return NX_ERROR;
+      }
+
+      // set the fgb's based on the fgb time stamp and the time resolution
+      int *p_fgb = nullptr;
+      if (rank == 1) {
+        p_fgb = new int;
+        *p_fgb = (int)(*f_data_ptr / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
+      } else { // rank == 2
+        p_fgb = new int[noOfElements];
+        for (int i=0; i<noOfElements; i++) {
+          *(p_fgb+i) = (int)(*(f_data_ptr+i) / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
+        }
+      }
+
+      if (!fNxEntry2->GetInstrument()->GetDetector()->SetFirstGoodBin(p_fgb)) {
+        std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+        return NX_ERROR;
+      }
+
+      // clean up
+      if (p_fgb) {
+        delete [] p_fgb;
+        p_fgb = 0;
+      }
+      if (data_ptr) {
+        delete [] data_ptr;
+        data_ptr = nullptr;
+      }
+
+      if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'first_good_time' data in NXdetector!")) return NX_ERROR;
     } else {
-      std::cerr << std::endl << ">> **ERROR** found 'time_zero' info in NXdetector with rank=" << rank << ". Do not know how to handle." << std::endl;
+      std::cerr << std::endl << ">> **WARNING** found neither 'first_good_bin' nor 'first_good_time' values ..." << std::endl;
-      return NX_ERROR;
     }
 
-    // calculate the needed size
+    // handle last good bin
-    size = dims[0];
+    if (SearchInGroup("last_good_bin", "name", nxname, nxclass, dataType)) {
-    for (int i=1; i<rank; i++)
+      if (!ErrorHandler(NXopendata(fFileHandle, "last_good_bin"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'last_good_bin' data in NXdetector!")) return NX_ERROR;
-      size *= dims[i];
-    noOfElements = size;
-    size *= GetDataSize(type);
 
-    // allocate locale memory to get the data
+      // check the dimensions of the 'last_good_bin' vector
-    char *data_ptr = new char[size];
+      if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'last_good_bin' info in NXdetector!")) return NX_ERROR;
-    if (data_ptr == nullptr) {
-      return NX_ERROR;
-    }
 
-    // get the data
+      // calculate the needed size
-    float *f_data_ptr = (float*) data_ptr;
+      size = dims[0];
-    int status = NXgetdata(fFileHandle, f_data_ptr);
+      for (int i=1; i<rank; i++)
-    if (status != NX_OK) {
+        size *= dims[i];
-      return NX_ERROR;
+      noOfElements = size;
-    }
+      size *= GetDataSize(type);
 
-    if (!ErrorHandler(GetStringAttr("units", str), PNEXUS_GET_ATTR_ERROR, "couldn't read 'time_zero' units in NXdetector!")) return NX_ERROR;
+      // allocate locale memory to get the data
-
+      char *data_ptr = new char[size];
-    // Set T0's
+      if (data_ptr == nullptr) {
-    // check that the necessary time resolution is present
+        return NX_ERROR;
-    if (fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str) == 0.0) {
-      std::cerr << std::endl << ">> **ERROR** trying to set T0's based on 'time_zero'. Need a valid time resolution to do so, but this is not given." << std::endl;
-      return NX_ERROR;
-    }
-    // set the t0's based on the t0 time stamp and the time resolution
-    int *pt0 = nullptr;
-    if (rank == 1) {
-      pt0 = new int;
-      *pt0 = (int)(*f_data_ptr / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
-    } else { // rank == 2
-      pt0 = new int[noOfElements];
-      for (int i=0; i<noOfElements; i++) {
-        *(pt0+i) = (int)(*(f_data_ptr+i) / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
       }
-    }
 
-    if (!fNxEntry2->GetInstrument()->GetDetector()->SetT0(pt0)) {
+      // get the data
-      std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+      int *i_data_ptr = (int*) data_ptr;
-      return NX_ERROR;
+      int status = NXgetdata(fFileHandle, i_data_ptr);
-    }
+      if (status != NX_OK) {
-
+        return NX_ERROR;
-    // clean up
-    if (data_ptr) {
-      delete [] data_ptr;
-      data_ptr = nullptr;
-    }
-
-    std::cerr << std::endl << ">> **WARNING** found only 'time_zero' will convert it to 'time_zero_bin' values" << std::endl;
-    if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'time_zero' data in NXdetector!")) return NX_ERROR;
-  } else {
-    std::cerr << std::endl << ">> **WARNING** found neither 'time_zero_bin' nor 'time_zero' values ..." << std::endl;
-  }
-
-  // handle first good bin
-  if (SearchInGroup("first_good_bin", "name", nxname, nxclass, dataType)) {
-    if (!ErrorHandler(NXopendata(fFileHandle, "first_good_bin"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'first_good_bin' data in NXdetector!")) return NX_ERROR;
-
-    // check the dimensions of the 'first_good_bin' vector
-    if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'first_good_bin' info in NXdetector!")) return NX_ERROR;
-
-    // calculate the needed size
-    size = dims[0];
-    for (int i=1; i<rank; i++)
-      size *= dims[i];
-    noOfElements = size;
-    size *= GetDataSize(type);
-
-    // allocate locale memory to get the data
-    char *data_ptr = new char[size];
-    if (data_ptr == nullptr) {
-      return NX_ERROR;
-    }
-
-    // get the data
-    int *i_data_ptr = (int*) data_ptr;
-    int status = NXgetdata(fFileHandle, i_data_ptr);
-    if (status != NX_OK) {
-      return NX_ERROR;
-    }
-
-    if (!fNxEntry2->GetInstrument()->GetDetector()->SetFirstGoodBin(i_data_ptr)) {
-      std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
-      return NX_ERROR;
-    }
-
-    if (data_ptr) {
-      delete [] data_ptr;
-      data_ptr = nullptr;
-    }
-
-    if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'first_good_bin' data in NXdetector!")) return NX_ERROR;
-  } else if (SearchInGroup("first_good_time", "name", nxname, nxclass, dataType)) {
-    if (!ErrorHandler(NXopendata(fFileHandle, "first_good_time"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'first_good_time' data in NXdetector!")) return NX_ERROR;
-
-    // check the dimensions of the 'first_good_time' vector
-    if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'first_good_time' info in NXdetector!")) return NX_ERROR;
-
-    // calculate the needed size
-    size = dims[0];
-    for (int i=1; i<rank; i++)
-      size *= dims[i];
-    noOfElements = size;
-    size *= GetDataSize(type);
-
-    // allocate locale memory to get the data
-    char *data_ptr = new char[size];
-    if (data_ptr == nullptr) {
-      return NX_ERROR;
-    }
-
-    // get the data
-    float *f_data_ptr = (float*) data_ptr;
-    int status = NXgetdata(fFileHandle, f_data_ptr);
-    if (status != NX_OK) {
-      return NX_ERROR;
-    }
-
-    // set the fgb's based on the fgb time stamp and the time resolution
-    int *p_fgb = nullptr;
-    if (rank == 1) {
-      p_fgb = new int;
-      *p_fgb = (int)(*f_data_ptr / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
-    } else { // rank == 2
-      p_fgb = new int[noOfElements];
-      for (int i=0; i<noOfElements; i++) {
-        *(p_fgb+i) = (int)(*(f_data_ptr+i) / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
       }
-    }
 
-    if (!fNxEntry2->GetInstrument()->GetDetector()->SetFirstGoodBin(p_fgb)) {
+      if (!fNxEntry2->GetInstrument()->GetDetector()->SetLastGoodBin(i_data_ptr)) {
-      std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+        std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
-      return NX_ERROR;
+        return NX_ERROR;
-    }
-
-    // clean up
-    if (p_fgb) {
-      delete [] p_fgb;
-      p_fgb = 0;
-    }
-    if (data_ptr) {
-      delete [] data_ptr;
-      data_ptr = nullptr;
-    }
-
-    if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'first_good_time' data in NXdetector!")) return NX_ERROR;
-  } else {
-    std::cerr << std::endl << ">> **WARNING** found neither 'first_good_bin' nor 'first_good_time' values ..." << std::endl;
-  }
-
-  // handle last good bin
-  if (SearchInGroup("last_good_bin", "name", nxname, nxclass, dataType)) {
-    if (!ErrorHandler(NXopendata(fFileHandle, "last_good_bin"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'last_good_bin' data in NXdetector!")) return NX_ERROR;
-
-    // check the dimensions of the 'last_good_bin' vector
-    if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'last_good_bin' info in NXdetector!")) return NX_ERROR;
-
-    // calculate the needed size
-    size = dims[0];
-    for (int i=1; i<rank; i++)
-      size *= dims[i];
-    noOfElements = size;
-    size *= GetDataSize(type);
-
-    // allocate locale memory to get the data
-    char *data_ptr = new char[size];
-    if (data_ptr == nullptr) {
-      return NX_ERROR;
-    }
-
-    // get the data
-    int *i_data_ptr = (int*) data_ptr;
-    int status = NXgetdata(fFileHandle, i_data_ptr);
-    if (status != NX_OK) {
-      return NX_ERROR;
-    }
-
-    if (!fNxEntry2->GetInstrument()->GetDetector()->SetLastGoodBin(i_data_ptr)) {
-      std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
-      return NX_ERROR;
-    }
-
-    // clean up
-    if (data_ptr) {
-      delete [] data_ptr;
-      data_ptr = nullptr;
-    }
-
-    if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'last_good_bin' data in NXdetector!")) return NX_ERROR;
-  } else if (SearchInGroup("last_good_time", "name", nxname, nxclass, dataType)) {
-    if (!ErrorHandler(NXopendata(fFileHandle, "last_good_time"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'last_good_time' data in NXdetector!")) return NX_ERROR;
-
-    // check the dimensions of the 'last_good_time' vector
-    if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'last_good_time' info in NXdetector!")) return NX_ERROR;
-
-    // calculate the needed size
-    size = dims[0];
-    for (int i=1; i<rank; i++)
-      size *= dims[i];
-    noOfElements = size;
-    size *= GetDataSize(type);
-
-    // allocate locale memory to get the data
-    char *data_ptr = new char[size];
-    if (data_ptr == nullptr) {
-      return NX_ERROR;
-    }
-
-    // get the data
-    float *f_data_ptr = (float*) data_ptr;
-    int status = NXgetdata(fFileHandle, f_data_ptr);
-    if (status != NX_OK) {
-      return NX_ERROR;
-    }
-
-    // set the lgb's based on the lgb time stamp and the time resolution
-    int *p_lgb = nullptr;
-    if (rank == 1) {
-      p_lgb = new int;
-      *p_lgb = (int)(*f_data_ptr / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
-    } else { // rank == 2
-      p_lgb = new int[noOfElements];
-      for (int i=0; i<noOfElements; i++) {
-        *(p_lgb+i) = (int)(*(f_data_ptr+i) / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
       }
-    }
 
-    if (fNxEntry2->GetInstrument()->GetDetector()->SetFirstGoodBin(p_lgb)) {
+      // clean up
-      std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+      if (data_ptr) {
-      return NX_ERROR;
+        delete [] data_ptr;
-    }
+        data_ptr = nullptr;
+      }
 
-    // clean up
+      if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'last_good_bin' data in NXdetector!")) return NX_ERROR;
-    if (p_lgb) {
+    } else if (SearchInGroup("last_good_time", "name", nxname, nxclass, dataType)) {
-      delete [] p_lgb;
+      if (!ErrorHandler(NXopendata(fFileHandle, "last_good_time"), PNEXUS_OPEN_DATA_ERROR, "couldn't open 'last_good_time' data in NXdetector!")) return NX_ERROR;
-      p_lgb = 0;
-    }
-    if (data_ptr) {
-      delete [] data_ptr;
-      data_ptr = nullptr;
-    }
 
-    if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'last_good_time' data in NXdetector!")) return NX_ERROR;
+      // check the dimensions of the 'last_good_time' vector
-  } else {
+      if (!ErrorHandler(NXgetinfo(fFileHandle, &rank, dims, &type), PNEXUS_GET_META_INFO_ERROR, "couldn't get 'last_good_time' info in NXdetector!")) return NX_ERROR;
-    std::cerr << std::endl << ">> **WARNING** found neither 'last_good_bin' nor 'last_good_time' values ..." << std::endl;
+
+      // calculate the needed size
+      size = dims[0];
+      for (int i=1; i<rank; i++)
+        size *= dims[i];
+      noOfElements = size;
+      size *= GetDataSize(type);
+
+      // allocate locale memory to get the data
+      char *data_ptr = new char[size];
+      if (data_ptr == nullptr) {
+        return NX_ERROR;
+      }
+
+      // get the data
+      float *f_data_ptr = (float*) data_ptr;
+      int status = NXgetdata(fFileHandle, f_data_ptr);
+      if (status != NX_OK) {
+        return NX_ERROR;
+      }
+
+      // set the lgb's based on the lgb time stamp and the time resolution
+      int *p_lgb = nullptr;
+      if (rank == 1) {
+        p_lgb = new int;
+        *p_lgb = (int)(*f_data_ptr / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
+      } else { // rank == 2
+        p_lgb = new int[noOfElements];
+        for (int i=0; i<noOfElements; i++) {
+          *(p_lgb+i) = (int)(*(f_data_ptr+i) / (float)fNxEntry2->GetInstrument()->GetDetector()->GetTimeResolution(str));
+        }
+      }
+
+      if (fNxEntry2->GetInstrument()->GetDetector()->SetFirstGoodBin(p_lgb)) {
+        std::cerr << std::endl << ">> **ERROR** " << fNxEntry2->GetInstrument()->GetDetector()->GetErrorMsg() << std::endl;
+        return NX_ERROR;
+      }
+
+      // clean up
+      if (p_lgb) {
+        delete [] p_lgb;
+        p_lgb = 0;
+      }
+      if (data_ptr) {
+        delete [] data_ptr;
+        data_ptr = nullptr;
+      }
+
+      if (!ErrorHandler(NXclosedata(fFileHandle), PNEXUS_CLOSE_DATA_ERROR, "couldn't close 'last_good_time' data in NXdetector!")) return NX_ERROR;
+    } else {
+      std::cerr << std::endl << ">> **WARNING** found neither 'last_good_bin' nor 'last_good_time' values ..." << std::endl;
+    }
   }
 
   // close group NXdetector

src/msr2data.cpp

@@ -512,7 +512,7 @@ int main(int argc, char *argv[])
       return 0;
     } else if (!strcmp(argv[1], "--version")) {
 #ifdef HAVE_CONFIG_H
-      std::cout << std::endl << "msr2data version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << ", ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
+      std::cout << std::endl << "msr2data version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
 #else
       std::cout << std::endl << "msr2data git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
 #endif

src/musrFT.cpp

@@ -297,7 +297,7 @@ Int_t musrFT_parse_options(Int_t argc, Char_t *argv[], musrFT_startup_param &sta
     tstr = argv[i];
     if (tstr.BeginsWith("--version")) {
 #ifdef HAVE_CONFIG_H
-      std::cout << std::endl << "musrFT version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << ", ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
+      std::cout << std::endl << "musrFT version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
 #else
       std::cout << std::endl << "musrFT git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
 #endif

src/musrRootValidation.cpp

@@ -574,7 +574,7 @@ int main(int argc, char *argv[])
   } else if (argc==2) {
     if (!strcmp(argv[1], "--version")) {
 #ifdef HAVE_CONFIG_H
-      std::cout << std::endl << "musrRootValidation version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
+      std::cout << std::endl << "musrRootValidation version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
 #else
       std::cout << std::endl << "musrRootValidation git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
 #endif

src/musredit_qt5/musredit/PMusrEditAbout.cpp

@@ -41,7 +41,7 @@ PMusrEditAbout::PMusrEditAbout(QWidget *parent) : QDialog(parent)
 
   fGitBranch_label->setText(QString("git-branch: %1").arg(GIT_BRANCH));
   fGitRev_label->setText(QString("git-rev: %1").arg(GIT_CURRENT_SHA1));
-  fMusrfitVersion_label->setText(QString("musrfit-version: %1").arg(PACKAGE_VERSION));
+  fMusrfitVersion_label->setText(QString("musrfit-version: %1 (%2)").arg(PACKAGE_VERSION).arg(BUILD_TYPE));
   fRootVersion_label->setText(QString("ROOT-version: %1").arg(ROOT_VERSION_USED));
 
   setModal(true);

src/musredit_qt6/musredit/PMusrEditAbout.cpp

@@ -41,7 +41,7 @@ PMusrEditAbout::PMusrEditAbout(QWidget *parent) : QDialog(parent)
 
   fGitBranch_label->setText(QString("git-branch: %1").arg(GIT_BRANCH));
   fGitRev_label->setText(QString("git-rev: %1").arg(GIT_CURRENT_SHA1));
-  fMusrfitVersion_label->setText(QString("musrfit-version: %1").arg(PACKAGE_VERSION));
+  fMusrfitVersion_label->setText(QString("musrfit-version: %1 (%2)").arg(PACKAGE_VERSION).arg(BUILD_TYPE));
   fRootVersion_label->setText(QString("ROOT-version: %1").arg(ROOT_VERSION_USED));
 
   setModal(true);

src/musrfit.cpp

@@ -464,7 +464,7 @@ int main(int argc, char *argv[])
   if (argc == 2) {
     if (!strcmp(argv[1], "--version")) {
 #ifdef HAVE_CONFIG_H
-      std::cout << std::endl << "musrfit version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << ", ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
+      std::cout << std::endl << "musrfit version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
 #else
       std::cout << std::endl << "musrfit git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
 #endif

src/musrt0.cpp

@@ -237,7 +237,7 @@ Int_t main(Int_t argc, Char_t *argv[])
   for (int i=1; i<argc; i++) {
     if (!strcmp(argv[i], "--version")) {
 #ifdef HAVE_CONFIG_H
-      std::cout << std::endl << "musrt0 version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << ", ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
+      std::cout << std::endl << "musrt0 version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
 #else
       std::cout << std::endl << "musrt0 git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
 #endif

src/musrview.cpp

@@ -135,7 +135,7 @@ int main(int argc, char *argv[])
       }
     } else if (!strcmp(argv[i], "--version")) {
 #ifdef HAVE_CONFIG_H
-      std::cout << std::endl << "musrview version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << ", ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
+      std::cout << std::endl << "musrview version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
 #else
       std::cout << std::endl << "musrview git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
 #endif

src/write_musrRoot_runHeader.cpp

@@ -61,9 +61,9 @@ int main(int argc, char *argv[])
 
   if (!strcmp(argv[1], "--version")) {
 #ifdef HAVE_CONFIG_H
-      std::cout << std::endl << "write_musrRoot_runHeader version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
+    std::cout << std::endl << "write_musrRoot_runHeader version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
 #else
-      std::cout << std::endl << "write_musrRoot_runHeader git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
+    std::cout << std::endl << "write_musrRoot_runHeader git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
 #endif
     return 0;
   }