ConfigurationUtility.h

#ifndef CONFIGURATION_UTILITY_H
#define CONFIGURATION_UTILITY_H

#include <Sct/AbcdModule.h>
#include <Sct/AbcdScans.h>
#include <Sct/AbcdChip.h>
#include "extraScans.h"
#include "SctApiFwd.h"

#include <iostream>
#include <sstream>

namespace SctApi{
class ConfigUtility{
 public:
  static unsigned diff(const ABCDBasic& first, const ABCDBasic& second, bool print=false);
  static unsigned diff(const ABCDConfig& first, const ABCDConfig& second, bool print=false);
  static unsigned diff(const ABCDCaldata& first, const ABCDCaldata& second, bool print=false);
  static unsigned diff(const ABCDChip& first, const ABCDChip& second, bool print=false);
  static unsigned diff(const ABCDModule& first, const ABCDModule& second, bool print=false);
  static unsigned diffSN(const ABCDModule& first, const ABCDModule& second, bool print=false);
  static std::auto_ptr<ABCDModule> clone(const ABCDModule& first);
  static std::auto_ptr<ABCDBasic> clone(const ABCDBasic& first);

  static void modifyVar(ABCDModule* module, UINT32 typ, FLOAT32 val);
  static void modifyVar(ABCDModule* module, unsigned chip, UINT32 typ, FLOAT32 val);

  static bool isBocRegister(UINT32 typ);

  static bool isModuleRegister(UINT32 typ);

  static bool isTimRegister(UINT32 typ);

  enum ConfigVarType {
    BOC_CHANNEL_CONFIG_VAR, BOC_GLOBAL_CONFIG_VAR,
    MODULE_GLOBAL_CONFIG_VAR, MODULE_CHIP_CONFIG_VAR, MODULE_CHANNEL_CONFIG_VAR,
    TIM_CONFIG_VAR, TRIGGER_VAR, UNKNOWN_CONFIG_VAR
  };

  static std::string apiBitFieldToString(unsigned bitfield);

  static ConfigVarType variableType(UINT32 typ);
 private:
  static ConfigUtility& ConfigUtility::instance();
  ConfigUtility();
  UINT16 config_compare_mask;
  static void setToken(ABCDModule* module, unsigned token, int link0, int link1);
  static INT32 ConfigUtility::setChipRole(ABCDModule *module, UINT32 theChip, ABCD_ROLES role);
};

inline std::auto_ptr<ABCDModule> ConfigUtility::clone(const ABCDModule& first){
  std::auto_ptr<ABCDModule> m (new ABCDModule);
  const size_t size=sizeof(ABCDModule);
  memcpy(m.get(), &first, size);
  return m;
}

inline std::auto_ptr<ABCDBasic> ConfigUtility::clone(const ABCDBasic& first){
  std::auto_ptr<ABCDBasic> a (new ABCDBasic);
  const size_t size=sizeof(ABCDBasic);
  memcpy(a.get(), &first, size);
  return a;
}

inline
ConfigUtility::ConfigUtility(){
  config_compare_mask=0xffffffff;
  reinterpret_cast<ABCDConfig*>(&config_compare_mask)->padding=0;
}

inline
ConfigUtility& ConfigUtility::instance(){
  static ConfigUtility config;
  return config;
}

// compare the first 14 bits only, since the last 2 are padding 
inline unsigned ConfigUtility::diff(const ABCDConfig& first, const ABCDConfig& second, bool print){
  unsigned diff_bits=SCTAPI_CONFIG_NONE;
  const UINT32* p=reinterpret_cast<const UINT32*>(&first);
  const UINT32* q=reinterpret_cast<const UINT32*>(&second);
  const UINT32& cfg_mask=instance().config_compare_mask;
  
  UINT32 cfgdiff = *p^*q;
  cfgdiff &= cfg_mask;
  if (cfgdiff) {
    diff_bits |= 1<<SCTAPI_CONFIG_CFG;
  }
  if (print && diff_bits) std::cout << "CFG: first = 0x" << std::hex << *p << " second = 0x" << *q << std::dec << std::endl;
  return diff_bits;
}

inline unsigned ConfigUtility::diff(const ABCDBasic& first, const ABCDBasic& second, bool print){
  unsigned diff_bits=0; 

  if  (first.vthr!=second.vthr || first.vcal!=second.vcal ||
       first.delay!=second.delay || first.preamp!=second.preamp ||
       first.shaper!=second.shaper) diff_bits|=1<<SCTAPI_CONFIG_BASIC;
  
  for (unsigned i=0; i<4; ++i){
    if (first.mask[i]!=second.mask[i]) diff_bits|=1<<SCTAPI_CONFIG_MASK;
  }
  if (print){
    if (first.vthr!=second.vthr) std::cout << "vthr first = " << +first.vthr << " second = " << +second.vthr << std::endl;
    if (first.vcal!=second.vcal) std::cout << "vcal first = " << +first.vcal << " second = " << +second.vcal << std::endl;
    if (first.delay!=second.delay) std::cout << "delay first = " << +first.delay << " second = " << +second.delay << std::endl;
    if (first.preamp!=second.preamp) std::cout << "preamp first = " << +first.preamp << " second = " << +second.preamp << std::endl;
    if (first.shaper!=second.shaper) std::cout << "shaper first = " << +first.shaper << " second = " << +second.shaper << std::endl;
    for (unsigned i=0; i<4; ++i){
      if (first.mask[i]!=second.mask[i]){
    std::cout << "mask[" << i<<"] first = 0x" << std::hex << +first.mask[i]  
          << " second = 0x" << +second.mask[i] << std::dec << std::endl;
      }
    }
  }
  diff_bits |= diff(first.config, second.config, print);
  return diff_bits;
}

inline unsigned ConfigUtility::diff(const ABCDCaldata& first, const ABCDCaldata& second, bool print){
  unsigned diff_bits=SCTAPI_CONFIG_NONE;

  if (first.rc_function!=second.rc_function || 
      first.c_factor!=second.c_factor) diff_bits |= 1<<SCTAPI_CONFIG_OTHER;

  for (unsigned i=0; i<3; ++i){
    if (first.rc_params[i]!=second.rc_params[i]) diff_bits |= 1<< SCTAPI_CONFIG_OTHER;
  }

  if (print){
    if (first.rc_function!=second.rc_function) {
      std::cout << "rc_function first = " << +first.rc_function << " second = " << +second.rc_function << std::endl;
    }
    if (first.c_factor!=second.c_factor) {
      std::cout << "c_factor first = " << first.c_factor << " second = " << second.c_factor << std::endl;
    }
    for (unsigned i=0; i<3; ++i){
      if (first.rc_params[i]!=second.rc_params[i]){
    std::cout << "rc_params[" << i << "] first = " << first.rc_params[i] 
          << " second = " << second.rc_params[i] << std::endl;  
      }
    }
  }
  return diff_bits;
}

inline unsigned ConfigUtility::diff(const ABCDChip& first, const ABCDChip& second, bool print){
  unsigned diff_bits=SCTAPI_CONFIG_NONE;
  
  for (unsigned i=0; i<N_SCT_CHANS; ++i){
    if (first.trim[i]!=second.trim[i]) {
      diff_bits |= 1<<SCTAPI_CONFIG_TRIM;
    }
  }
  if (diff_bits && print){
    unsigned start, stop;
    for (unsigned iset=0; iset<4; ++iset){
      start=iset*32;
      stop=(iset+1)*32-1;
      std::cout << "trim ["<<start<<"->"<<stop<<"] first = 0x" << std::hex;
      for (unsigned ii=start; ii<stop; ++ii){ 
    std::cout << +first.trim[ii];
      }
      std::cout << " second = 0x";
      for (unsigned ii=start; ii<stop; ++ii){ 
    std::cout << +second.trim[ii];
      }
      std::cout << std::dec << std::endl;
    }
  }

  if (first.active!=second.active ||
      first.address!=second.address ||
      first.target!=second.target ) diff_bits |= 1<<SCTAPI_CONFIG_OTHER;  
  
  if (print){
    if (first.active!=second.active) std::cout << "active first = " << +first.active << " second = " << +second.active << std::endl;
    if (first.address!=second.address) std::cout << "address first = " << +first.address << " second = " << +second.address << std::endl;
    if (first.target!=second.target) std::cout << "target first = " << +first.target << " second = " << +second.target << std::endl;
  }

  diff_bits |= diff(first.basic, second.basic, print);
  diff_bits |= diff(first.caldata, second.caldata, print);

  return diff_bits;
}

inline unsigned ConfigUtility::diff(const ABCDModule& first, const ABCDModule& second, bool print){
  unsigned diff_bits=SCTAPI_CONFIG_NONE;
  
  for (unsigned ichip=0; ichip<N_SCT_CHIPS; ++ichip){
    if (print) std::cout << "chip " << ichip << std::endl;
    diff_bits |= diff(first.chip[ichip], second.chip[ichip], print);
  }
  
  if (first.active!=second.active ||  // ignore present and dataPresent (handled by ROD)
      first.select!=second.select || first.groupId!=second.groupId ||
      first.pTTC!=second.pTTC || first.rTTC!=second.rTTC ||
      first.rx[0]!=second.rx[0] || first.rx[1]!=second.rx[1] ||
      first.mid != second.mid
      ){
    diff_bits |= 1<<SCTAPI_CONFIG_OTHER;
  }
  if (print){
    if (first.active!=second.active) std::cout << "active first = " << +first.active << " second = " << +second.active << std::endl;
    if (first.select!=second.select) std::cout << "select first = " << +first.select << " second = " << +second.select << std::endl;
    if (first.pTTC!=second.pTTC) std::cout << "pTTC first = " << +first.pTTC << " second = " << +second.pTTC << std::endl;
    if (first.rx[0]!=second.rx[0]) std::cout << "rx[0] first = " << +first.rx[0] << " second = " << +second.rx[0] << std::endl;
    if (first.rx[1]!=second.rx[1]) std::cout << "rx[1] first = " << +first.rx[1] << " second = " << +second.rx[1] << std::endl;
    if (first.mid!=second.mid) std::cout << "mid first = " << +first.mid << " second = " << +second.mid << std::endl;
  }

  diff_bits |= diffSN(first, second);
  return diff_bits;
}

inline unsigned ConfigUtility::diffSN(const ABCDModule& first, const ABCDModule& second, bool print){
  unsigned diff_bits=0;
  for (unsigned i=0; i<16; ++i){
    if (first.serialNumber[i] != second.serialNumber[i]) diff_bits&= 1<<SCTAPI_CONFIG_OTHER;
  }
  if (diff_bits && print ){
    std::cout << "s/n first = " << first.serialNumber << " second = " << second.serialNumber << std::endl;
  }
  return diff_bits;
}

inline std::string ConfigUtility::apiBitFieldToString(unsigned bitfield){
  std::ostringstream oss;
  if (bitfield & 1 << SCTAPI_CONFIG_CFG) oss << "Cfg";
  if (bitfield & 1 << SCTAPI_CONFIG_BASIC) oss << "Basic";
  if (bitfield & 1 << SCTAPI_CONFIG_TRIM) oss << "Trim";
  if (bitfield & 1 << SCTAPI_CONFIG_MASK) oss << "Mask";
  if (bitfield & 1 << SCTAPI_CONFIG_OTHER) oss << "Other";
  if (bitfield & 1 << SCTAPI_CONFIG_ALL) oss << "All";
  return oss.str();
}

inline bool ConfigUtility::isBocRegister(UINT32 typ){
  if (variableType(typ)==BOC_CHANNEL_CONFIG_VAR || 
      variableType(typ)==BOC_GLOBAL_CONFIG_VAR){
    return true;
  }
  return false;
}

inline bool ConfigUtility::isTimRegister(UINT32 typ){
  if (variableType(typ)==TIM_CONFIG_VAR ){
    return true;
  }
  return false;
}

inline bool ConfigUtility::isModuleRegister(UINT32 typ){
  if (variableType(typ)==MODULE_GLOBAL_CONFIG_VAR || 
      variableType(typ)==MODULE_CHIP_CONFIG_VAR || 
      variableType(typ)==MODULE_CHANNEL_CONFIG_VAR ) {
    return true;
  }
  return false;
}

}

#endif

---