SctApiModify.cxx

#include <iostream>
#include <cmath>

#include "processor.h"

#include "Sct/AbcdScans.h"
#include "primParams.h"     // This has MVAR variables which are shared with PIXEL
#include "Sct/AbcdChip.h"

#include "SctApi.h"
#include "crate.h"
#include "utility.h"

#include "extraScans.h"
#include "ConfigurationUtility.h"

using namespace std;

namespace SctApi {

void printBanks(list<BankType> banks, std::ostream& os);

void SctApi::setAutoUpdateBanks(std::list<BankType> banks){
  std::cout << "AutoUpdate has been set for ROD banks: ";  
  printBanks(banks, std::cout); std::cout << std::endl;
  m_autoUpdateBanks=banks;
}

void SctApi::modifyABCDMask(UINT32 mid, UINT32* mask) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "modifyABCDMask on " << mid << "\n";
  }

  ABCDModule *module = lookupConfig(mid);

  if(module) {
    for(int c=0; c<12; c++) {
      for(int m=0; m<4; m++) {
        module->chip[c].basic.mask[m] = mask[c*4+m];
      }
    }
  } 
}

void SctApi::modifyABCDRC(UINT32 mid, UINT32 chip, UINT16 index, FLOAT32 p0, FLOAT32 p1, FLOAT32 p2){
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "modifyABCDRC on " << mid << " " << chip << "\n";
  }
  ABCDModule *module = lookupConfig(mid);

  if(module) {
    module->chip[chip].caldata.rc_function = index;
    module->chip[chip].caldata.rc_params[0]=p0;
    module->chip[chip].caldata.rc_params[1]=p1;
    module->chip[chip].caldata.rc_params[2]=p2;
  }
}

void SctApi::modifyABCDTrims(UINT32 mid, UINT8* trims) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "modifyABCDTrims on " << mid << "\n";
  }

  ABCDModule *module = lookupConfig(mid);

  if(module) {
    for(int c=0; c<12; c++) {
      for(int t=0; t<128; t++) {
        module->chip[c].trim[t] = trims[c*128+t];
      }
    }
  }
}

#define fToInt(val) ((int)((val)+0.5))

void SctApi::modifyABCDVar(UINT32 typ, FLOAT32 val) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "modifyABCDVar (all)\n";
  }

  cout << "Modify var on all modules: setting " << typ << " to " << val << endl;

#warning "Suggest using ConfigUtility::variableType to find BOC_GLOBAL_CONFIG_VAR's"

  switch(typ) {
    // Global BOC registers
  case SCT_SCAN_BOC_BPM_PHASE:
  case SCT_SCAN_BOC_BREG_PHASE:
  case SCT_SCAN_BOC_V0_PHASE:
  case SCT_SCAN_BOC_V1_PHASE:
  case SCT_SCAN_BOC_V_PHASES:
  case SCT_SCAN_BOC_VRN_FINE:

  case SCT_SCAN_TX_CHANNELS:
  case SCT_SCAN_RAW_TX_CHANNELS:
    {
      cout << "Calling modifyBOCParam on all crates for " << typ << " " << val << endl;

      try {
        for(list<RodLabel>::const_iterator rl = rodList.begin();
            rl!=rodList.end();
            rl++){
          getCrate()->modifyBOCParam(typ, fToInt(val), false);
        }
      } catch(CrateException &c) {
        cout << "CrateException: " << c.what() << endl;
      }
      break;
    }

  default:
    // Module level parameters
    for(map<UINT32, ABCDModule>::const_iterator iter = moduleMap.begin();
        iter != moduleMap.end();
        iter ++) {
      modifyABCDVar(iter->first, typ, val);
    }
    if (!m_autoUpdateBanks.empty() && ConfigUtility::isModuleRegister(typ)){
      modifyABCDVarROD(typ, val, m_autoUpdateBanks);
    }
    break;
  }
}
  
void SctApi::modifyABCDVarAllModulesOneChip(UINT32 chip, UINT32 typ, FLOAT32 val){
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "modifyABCDVarAllModulesOneChip (chip " << chip << ") " << typ << " " << val << "\n";
  }
  if (ConfigUtility::variableType(typ)!=ConfigUtility::MODULE_CHIP_CONFIG_VAR && 
      ConfigUtility::variableType(typ)!=ConfigUtility::MODULE_CHANNEL_CONFIG_VAR){
    std::cout << "Variable " << typ << " of type " << ConfigUtility::variableType(typ) 
          << " cannot be modified at the chip level!" << std::endl;
    return;
  }
  for(map<UINT32, ABCDModule>::const_iterator iter = moduleMap.begin();
      iter != moduleMap.end();
      iter ++) {
    modifyABCDVar(iter->first, chip, typ, val);
  }
}

void SctApi::modifyABCDVar(UINT32 mid, UINT32 typ, FLOAT32 val) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "modifyABCDVar (module " << mid << ") " << typ << " " << val << "\n";
  }

#warning "Suggest using ConfigUtility::variableType to pick out BOC params"

  switch(typ) {
    // First some module parameters (BOC)
  case ST_RX_DELAY:
  case ST_RX_DELAY0:
  case ST_RX_DELAY1:
  case ST_RX_THRESHOLD:
  case ST_RX_THRESHOLD0:
  case ST_RX_THRESHOLD1:
  case ST_TX_CURRENT:
  case ST_TX_MARKSPACE:
  case ST_TX_DELAY:
  case ST_TX_COARSE:
  case ST_TX_FINE:

    // Global BOC registers
  case SCT_SCAN_BOC_BPM_PHASE:
  case SCT_SCAN_BOC_BREG_PHASE:
  case SCT_SCAN_BOC_V0_PHASE:
  case SCT_SCAN_BOC_V1_PHASE:
  case SCT_SCAN_BOC_V_PHASES:
  case SCT_SCAN_BOC_VRN_FINE:

  case SCT_SCAN_TX_CHANNELS:
  case SCT_SCAN_RAW_TX_CHANNELS:
    {
      unsigned int partition, crate, rod, channel;
      Utility::getpcrc(mid, partition, crate, rod, channel);

      cout << "Calling BOCCard method for module " << mid << " " << typ << " " << val << endl;

      try {
        // Do channel mapping
        getCrate()->modifyBOCParam(rod, channel, typ, fToInt(val), false);
      } catch(CrateException &c) {
        cout << "CrateException: " << c.what() << endl;
      }
      break;
    }

  default:
    ABCDModule *mConf = lookupConfig(mid);
    if (mConf){
      ConfigUtility::modifyVar(mConf, typ, val);
    }else{
      cout << "No module configuration to change\n";
      return;
    }
    if (!m_autoUpdateBanks.empty() && ConfigUtility::isModuleRegister(typ)){
      modifyABCDVarROD(mid, typ, val, m_autoUpdateBanks);
    }
  }
}

void SctApi::modifyABCDVar(UINT32 mid, UINT32 chip, UINT32 typ, FLOAT32 val) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "modifyABCDVar (module " << mid << ": chip " << chip  << ") " << typ << " " << val << "\n";
  }

  ABCDModule *mConf = lookupConfig(mid);

  if(!mConf) {
    cout << "No module configuration to change\n";
    return;
  }

  ConfigUtility::modifyVar(mConf, chip, typ, val);
  if (!m_autoUpdateBanks.empty()  && ConfigUtility::isModuleRegister(typ)){
    modifyABCDVarROD(mid, chip, typ, val, m_autoUpdateBanks);
  }
}

}

---