/////////////////////////////////////////////////////////////////////
// PixFeI2Config.cxx
// version 1.0
/////////////////////////////////////////////////////////////////////
//
// 30/04/04  Version 1.0 (CS)
//           Initial release
//

//! PixFeConfig implementation for FE-I2

#include <math.h>
#include <iomanip>
#include <sstream>
#include <typeinfo>

#include "serialStreams.h"
#include "Bits/Bits.h"
#include "Config/Config.h"
#include "PixFe/PixFeExc.h"
#include "PixFe/PixFeStructures.h"
#include "PixFe/PixFeData.h"
#include "PixConfDBInterface/PixConfDBInterface.h"
#include "PixFe/PixFeI2Config.h"

using namespace PixLib;


//! Constructor
PixFeI2Config::PixFeI2Config(PixConfDBInterface *db, DBInquire *dbInquire, std::string name, int number) {
  // Members initialization
  m_db = db;
  m_dbInquire = dbInquire;
  m_name = name;
  m_className = "PixFeI2";

  // Setup config structures
  setupStructures();
    
  // Setup default data
  m_data.setFeStructures(&m_structures);
  m_data.setIndex(number);
  setupData();

  // Setup config object
  setupConfigObject();

  // Load initial config from database
  if(m_db!=0 && m_dbInquire!=0) loadConfig("PHYSICS");
}

//! Copy constructor
PixFeI2Config::PixFeI2Config(const PixFeConfig &c) {
  // Members initialization
  m_className = "PixFeI2";

  // Try dynamic casting
  try {
    const PixFeI2Config& cfg = dynamic_cast<const PixFeI2Config&>(c);
    
    // Setup config structures
    setupStructures();
    m_data.setFeStructures(&m_structures);

    // Copy database information
    m_db = cfg.m_db;
    m_dbInquire = cfg.m_dbInquire;
    m_name = cfg.m_name;

    // Copy config data
    m_data = cfg.m_data;

    // Setup config object
    setupConfigObject();
  }
  catch(bad_cast) {
    throw PixFeExc(PixFeExc::CASTING_MISMATCH, PixFeExc::ERROR, m_name);
    return;
  }
}

//! Destructor
PixFeI2Config::~PixFeI2Config() {
}


//! Assignment operator
PixFeConfig& PixFeI2Config::operator = (const PixFeConfig& c) {

  if(this != &c) {
    // Try dynamic casting
    try {
      const PixFeI2Config& cfg = dynamic_cast<const PixFeI2Config&>(c);
      m_data = cfg.m_data;
    }
    catch(bad_cast) {
      throw PixFeExc(PixFeExc::CASTING_MISMATCH, PixFeExc::ERROR, m_name);
      return *this;
    }
  }

  return *this;
}


//! Global register copy method
void PixFeI2Config::copyGlobReg(const PixFeConfig& source) {
  if(this != &source) {
    // Try dynamic casting
    try {
      const PixFeI2Config& cfg = dynamic_cast<const PixFeI2Config&>(source);
      m_data.copyGlobReg(cfg.m_data);
    }
    catch(bad_cast) {
      throw PixFeExc(PixFeExc::CASTING_MISMATCH, PixFeExc::ERROR, m_name);
      return;
    }
  }
}

//! Pixel register copy method
void PixFeI2Config::copyPixReg(const PixFeConfig& source, std::string name) {
  if(this != &source) {
    // Try dynamic casting
    try {
      const PixFeI2Config& cfg = dynamic_cast<const PixFeI2Config&>(source);
      m_data.copyPixReg(cfg.m_data, name);
    }
    catch(bad_cast) {
      throw PixFeExc(PixFeExc::CASTING_MISMATCH, PixFeExc::ERROR, m_name);
      return;
    }
  }
}

//! Trim copy method
void PixFeI2Config::copyTrim(const PixFeConfig& source, std::string name) {
  if(this != &source) {
    // Try dynamic casting
    try {
      const PixFeI2Config& cfg = dynamic_cast<const PixFeI2Config&>(source);
      m_data.copyTrim(cfg.m_data, name);
    }
    catch(bad_cast) {
      throw PixFeExc(PixFeExc::CASTING_MISMATCH, PixFeExc::ERROR, m_name);
      return;
    }
  }
}


//! Setup FE configuration structures elements
void PixFeI2Config::setupStructures() {
  // Setup FE general parameters
  m_structures.nCol(18);
  m_structures.nRow(160);
  
  // Setup FE Global Register
  if(m_structures.getGlobRegSize() == 0) {
    m_structures.setGlobReg("LATENCY",                8, 0);
    m_structures.setGlobReg("DAC_IVDD2",              8, 8);
    m_structures.setGlobReg("DAC_IP2",                8, 16);
    m_structures.setGlobReg("DAC_ID",                 8, 24);
    m_structures.setGlobReg("DAC_IP",                 8, 32);
    m_structures.setGlobReg("DAC_ITRIMTH",            8, 40);
    m_structures.setGlobReg("DAC_IF",                 8, 48);
    m_structures.setGlobReg("DAC_ITH1",               8, 56);
    m_structures.setGlobReg("DAC_ITH2",               8, 64);
    m_structures.setGlobReg("DAC_IL",                 8, 72);    
    m_structures.setGlobReg("DAC_IL2",                8, 80);    
    m_structures.setGlobReg("DAC_ITRIMIF",            8, 88);
    m_structures.setGlobReg("DAC_SPARE",              8, 96);
    m_structures.setGlobReg("THRESH_TOT_MINIMUM",     8, 104);
    m_structures.setGlobReg("THRESH_TOT_DOUBLE",      8, 112);
    m_structures.setGlobReg("CAP_MEASURE",            6, 120);
    m_structures.setGlobReg("GLOBAL_DAC",             5, 120); // Every address has to be rearranged!!! Things have changed a lot!!!
    m_structures.setGlobReg("MUX_TEST_PIXEL",         2, 126);
    m_structures.setGlobReg("DAC_MON_LEAK_ADC",       9, 128);
    m_structures.setGlobReg("DAC_VCAL",              10, 137);
    m_structures.setGlobReg("WIDTH_SELF_TRIGGER",     4, 147);
    m_structures.setGlobReg("MUX_DO",                 4, 151);
    m_structures.setGlobReg("MUX_MON_HIT",            4, 155);
    m_structures.setGlobReg("MUX_EOC",                2, 159);
    m_structures.setGlobReg("FREQUENCY_CEU",          2, 161); 
    m_structures.setGlobReg("MODE_TOT_THRESH",        2, 163);
    m_structures.setGlobReg("ENABLE_TIMESTAMP",       1, 165);
    m_structures.setGlobReg("ENABLE_SELF_TRIGGER",    1, 166);
    m_structures.setGlobReg("SPARE",                  1, 167);
    m_structures.setGlobReg("MON_MON_LEAK_ADC",       1, 168);
    m_structures.setGlobReg("MON_ADC_REF",            1, 169);
    m_structures.setGlobReg("ENABLE_MON_LEAK",        1, 170);
    m_structures.setGlobReg("STATUS_MON_LEAK",        1, 171);
    m_structures.setGlobReg("ENABLE_CAP_TEST",        1, 172);
    m_structures.setGlobReg("ENABLE_BUFFER",          1, 173);
    m_structures.setGlobReg("ENABLE_VCAL_MEASURE",    1, 174);
    m_structures.setGlobReg("ENABLE_LEAK_MEASURE",    1, 175);
    m_structures.setGlobReg("ENABLE_BUFFER_BOOST",    1, 176);
    m_structures.setGlobReg("ENABLE_CP8",             1, 177);
    m_structures.setGlobReg("MON_IVDD2",              1, 178);
    m_structures.setGlobReg("MON_ID",                 1, 179);
    m_structures.setGlobReg("ENABLE_CP7",             1, 180);
    m_structures.setGlobReg("MON_IP2",                1, 181);
    m_structures.setGlobReg("MON_IP",                 1, 182);
    m_structures.setGlobReg("ENABLE_CP6",             1, 183);
    m_structures.setGlobReg("MON_ITRIMTH",            1, 184);
    m_structures.setGlobReg("MON_IF",                 1, 185);
    m_structures.setGlobReg("ENABLE_CP5",             1, 186);
    m_structures.setGlobReg("MON_ITRIMIF",            1, 187);
    m_structures.setGlobReg("MON_VCAL",               1, 188);
    m_structures.setGlobReg("ENABLE_CP4",             1, 189);
    m_structures.setGlobReg("ENABLE_CINJ_HIGH",       1, 190);
    m_structures.setGlobReg("ENABLE_EXTERNAL",        1, 191);
    m_structures.setGlobReg("ENABLE_TEST_ANALOG_REF", 1, 192);
    m_structures.setGlobReg("ENABLE_DIGITAL",         1, 193);
    m_structures.setGlobReg("ENABLE_CP3",             1, 194);
    m_structures.setGlobReg("MON_ITH1",               1, 195);
    m_structures.setGlobReg("MON_ITH2",               1, 196);
    m_structures.setGlobReg("ENABLE_CP2",             1, 197);
    m_structures.setGlobReg("MON_IL",                 1, 198);
    m_structures.setGlobReg("MON_IL2",                1, 199);
    m_structures.setGlobReg("ENABLE_CP1",             1, 200);
    m_structures.setGlobReg("ENABLE_CP0",             1, 201);
    m_structures.setGlobReg("MON_SPARE",              1, 202);
    m_structures.setGlobReg("ENABLE_BIASCOMP",        1, 203);
    m_structures.setGlobReg("ENABLE_AUTOTUNE",        1, 204);
    m_structures.setGlobReg("ENABLE_HITBUS",          1, 205);
    m_structures.setGlobReg("SELF_WIDTH",             4, 206);
    m_structures.setGlobReg("SELF_LATENCY",           4, 210);
  }
  
  // Setup FE Pixel Register
  m_structures.setPixReg("HITBUS", 0);
  m_structures.setPixReg("SELECT", 1);
  m_structures.setPixReg("PREAMP", 2);
  m_structures.setPixReg("ENABLE", 3);
  
  // Setup FE Trims
  m_structures.setTrim("TDAC", 0, 5, 0xff);
  m_structures.setTrim("FDAC", 5, 5, 0x7);
}

    
void PixFeI2Config::setupData() {
  // Setup global register default values
  PixFeStructures::nameIterator name, nameEnd=m_structures.globRegEnd();
  for(name = m_structures.globRegBegin(); name != nameEnd; name++)
    writeGlobRegister(*name, 0x0);
		
  // Setup pixel registers default values
  ConfMask<bool> pixDefault(m_structures.nCol(), m_structures.nRow(), 1, 1);
  nameEnd=m_structures.pixRegEnd();
  for(name = m_structures.pixRegBegin(); name != nameEnd; name++)
    writePixRegister(*name, pixDefault);
		
  // Setup trim default values
  nameEnd=m_structures.trimEnd();
  for(name = m_structures.trimBegin(); name != nameEnd; name++) {
    int max;
    m_structures.getTrimMax(*name, max);
    ConfMask<unsigned short int> trimDefault(m_structures.nCol(), m_structures.nRow(), max, max);
    writeTrim(*name, trimDefault);
  }
}


//! Copy config to Primitive input structure
void PixFeI2Config::fillConfig(PixelModule *mod) {
  // Copy FE global registers content
  int number = m_data.getIndex();
  //  cout << "Do config is set to " << (m_data.getCfgEn()?"ON":"OFF") << endl;
  try {
    mod->FEConfig[number].FEGlobal.latency		 = m_data.getCfgEn()?readGlobRegister("LATENCY"):0;
    mod->FEConfig[number].FEGlobal.dacIVDD2 		 = m_data.getCfgEn()?readGlobRegister("DAC_IVDD2"):0;
    mod->FEConfig[number].FEGlobal.dacIP2 		 = m_data.getCfgEn()?readGlobRegister("DAC_IP2"):0;
    mod->FEConfig[number].FEGlobal.dacID		 = m_data.getCfgEn()?readGlobRegister("DAC_ID"):0;
    mod->FEConfig[number].FEGlobal.dacIP		 = m_data.getCfgEn()?readGlobRegister("DAC_IP"):0;
    mod->FEConfig[number].FEGlobal.dacITRIMTH            = m_data.getCfgEn()?readGlobRegister("DAC_ITRIMTH"):0;
    mod->FEConfig[number].FEGlobal.dacIF		 = m_data.getCfgEn()?readGlobRegister("DAC_IF"):0;
    mod->FEConfig[number].FEGlobal.dacITH1		 = m_data.getCfgEn()?readGlobRegister("DAC_ITH1"):0;
    mod->FEConfig[number].FEGlobal.dacITH2		 = m_data.getCfgEn()?readGlobRegister("DAC_ITH2"):0;
    mod->FEConfig[number].FEGlobal.dacIL		 = m_data.getCfgEn()?readGlobRegister("DAC_IL"):0;
    mod->FEConfig[number].FEGlobal.dacIL2 		 = m_data.getCfgEn()?readGlobRegister("DAC_IL2"):0;
    mod->FEConfig[number].FEGlobal.dacITRIMIF            = m_data.getCfgEn()?readGlobRegister("DAC_ITRIMIF"):0;
    mod->FEConfig[number].FEGlobal.dacSpare 		 = m_data.getCfgEn()?readGlobRegister("DAC_SPARE"):0;
    mod->FEConfig[number].FEGlobal.threshTOTMinimum 	 = m_data.getCfgEn()?readGlobRegister("THRESH_TOT_MINIMUM"):0;
    mod->FEConfig[number].FEGlobal.threshTOTDouble	 = m_data.getCfgEn()?readGlobRegister("THRESH_TOT_DOUBLE"):0;
    mod->FEConfig[number].FEGlobal.capMeasure    	 = m_data.getCfgEn()?readGlobRegister("CAP_MEASURE"):0;
    mod->FEConfig[number].FEGlobal.gdac       	         = m_data.getCfgEn()?readGlobRegister("GLOBAL_DAC"):0;
    mod->FEConfig[number].FEGlobal.muxTestPixel 	 = m_data.getCfgEn()?readGlobRegister("MUX_TEST_PIXEL"):0;
    mod->FEConfig[number].FEGlobal.dacMonLeakADC	 = m_data.getCfgEn()?readGlobRegister("DAC_MON_LEAK_ADC"):0;
    mod->FEConfig[number].FEGlobal.dacVCAL		 = m_data.getCfgEn()?readGlobRegister("DAC_VCAL"):0;
    mod->FEConfig[number].FEGlobal.widthSelfTrigger 	 = m_data.getCfgEn()?readGlobRegister("WIDTH_SELF_TRIGGER"):0;
    mod->FEConfig[number].FEGlobal.muxDO		 = m_data.getCfgEn()?readGlobRegister("MUX_DO"):0;
    mod->FEConfig[number].FEGlobal.muxMonHit		 = m_data.getCfgEn()?readGlobRegister("MUX_MON_HIT"):0;
    mod->FEConfig[number].FEGlobal.muxEOC 		 = m_data.getCfgEn()?readGlobRegister("MUX_EOC"):0;
    mod->FEConfig[number].FEGlobal.frequencyCEU 	 = m_data.getCfgEn()?readGlobRegister("FREQUENCY_CEU"):0;
    mod->FEConfig[number].FEGlobal.modeTOTThresh	 = m_data.getCfgEn()?readGlobRegister("MODE_TOT_THRESH"):0;
    mod->FEConfig[number].FEGlobal.enableTimestamp	 = m_data.getCfgEn()?readGlobRegister("ENABLE_TIMESTAMP"):0;
    mod->FEConfig[number].FEGlobal.enableSelfTrigger	 = m_data.getCfgEn()?readGlobRegister("ENABLE_SELF_TRIGGER"):0;
    mod->FEConfig[number].FEGlobal.spare		 = m_data.getCfgEn()?readGlobRegister("SPARE"):0;
    mod->FEConfig[number].FEGlobal.monMonLeakADC	 = m_data.getCfgEn()?readGlobRegister("MON_MON_LEAK_ADC"):0;
    mod->FEConfig[number].FEGlobal.monADCRef		 = m_data.getCfgEn()?readGlobRegister("MON_ADC_REF"):0;
    mod->FEConfig[number].FEGlobal.enableMonLeak	 = m_data.getCfgEn()?readGlobRegister("ENABLE_MON_LEAK"):0;
    mod->FEConfig[number].FEGlobal.statusMonLeak	 = m_data.getCfgEn()?readGlobRegister("STATUS_MON_LEAK"):0;
    mod->FEConfig[number].FEGlobal.enableCapTest	 = m_data.getCfgEn()?readGlobRegister("ENABLE_CAP_TEST"):0;
    mod->FEConfig[number].FEGlobal.enableBuffer 	 = m_data.getCfgEn()?readGlobRegister("ENABLE_BUFFER"):0;
    mod->FEConfig[number].FEGlobal.enableVcalMeasure	 = m_data.getCfgEn()?readGlobRegister("ENABLE_VCAL_MEASURE"):0;
    mod->FEConfig[number].FEGlobal.enableLeakMeasure	 = m_data.getCfgEn()?readGlobRegister("ENABLE_LEAK_MEASURE"):0;
    mod->FEConfig[number].FEGlobal.enableBufferBoost	 = m_data.getCfgEn()?readGlobRegister("ENABLE_BUFFER_BOOST"):0;
    mod->FEConfig[number].FEGlobal.enableCP8		 = m_data.getCfgEn()?readGlobRegister("ENABLE_CP8"):0;
    mod->FEConfig[number].FEGlobal.monIVDD2 		 = m_data.getCfgEn()?readGlobRegister("MON_IVDD2"):0;
    mod->FEConfig[number].FEGlobal.monID		 = m_data.getCfgEn()?readGlobRegister("MON_ID"):0;
    mod->FEConfig[number].FEGlobal.enableCP7		 = m_data.getCfgEn()?readGlobRegister("ENABLE_CP7"):0;
    mod->FEConfig[number].FEGlobal.monIP2 		 = m_data.getCfgEn()?readGlobRegister("MON_IP2"):0;
    mod->FEConfig[number].FEGlobal.monIP		 = m_data.getCfgEn()?readGlobRegister("MON_IP"):0;
    mod->FEConfig[number].FEGlobal.enableCP6		 = m_data.getCfgEn()?readGlobRegister("ENABLE_CP6"):0;
    mod->FEConfig[number].FEGlobal.monITRIMTH            = m_data.getCfgEn()?readGlobRegister("MON_ITRIMTH"):0;
    mod->FEConfig[number].FEGlobal.monIF		 = m_data.getCfgEn()?readGlobRegister("MON_IF"):0;
    mod->FEConfig[number].FEGlobal.enableCP5		 = m_data.getCfgEn()?readGlobRegister("ENABLE_CP5"):0;
    mod->FEConfig[number].FEGlobal.monITRIMIF            = m_data.getCfgEn()?readGlobRegister("MON_ITRIMIF"):0;
    mod->FEConfig[number].FEGlobal.monVCAL		 = m_data.getCfgEn()?readGlobRegister("MON_VCAL"):0;
    mod->FEConfig[number].FEGlobal.enableCP4		 = m_data.getCfgEn()?readGlobRegister("ENABLE_CP4"):0;
    mod->FEConfig[number].FEGlobal.enableCinjHigh 	 = m_data.getCfgEn()?readGlobRegister("ENABLE_CINJ_HIGH"):0;
    mod->FEConfig[number].FEGlobal.enableExternal 	 = m_data.getCfgEn()?readGlobRegister("ENABLE_EXTERNAL"):0;
    mod->FEConfig[number].FEGlobal.enableTestAnalogRef   = m_data.getCfgEn()?readGlobRegister("ENABLE_TEST_ANALOG_REF"):0;
    mod->FEConfig[number].FEGlobal.enableDigital	 = m_data.getCfgEn()?readGlobRegister("ENABLE_DIGITAL"):0;
    mod->FEConfig[number].FEGlobal.enableCP3		 = m_data.getCfgEn()?readGlobRegister("ENABLE_CP3"):0;
    mod->FEConfig[number].FEGlobal.monITH1		 = m_data.getCfgEn()?readGlobRegister("MON_ITH1"):0;
    mod->FEConfig[number].FEGlobal.monITH2		 = m_data.getCfgEn()?readGlobRegister("MON_ITH2"):0;
    mod->FEConfig[number].FEGlobal.enableCP2		 = m_data.getCfgEn()?readGlobRegister("ENABLE_CP2"):0;
    mod->FEConfig[number].FEGlobal.monIL		 = m_data.getCfgEn()?readGlobRegister("MON_IL"):0;
    mod->FEConfig[number].FEGlobal.monIL2 		 = m_data.getCfgEn()?readGlobRegister("MON_IL2"):0;
    mod->FEConfig[number].FEGlobal.enableCP1		 = m_data.getCfgEn()?readGlobRegister("ENABLE_CP1"):0;
    mod->FEConfig[number].FEGlobal.enableCP0		 = m_data.getCfgEn()?readGlobRegister("ENABLE_CP0"):0;
    mod->FEConfig[number].FEGlobal.monSpare 		 = m_data.getCfgEn()?readGlobRegister("MON_SPARE"):0;

    mod->FEConfig[number].FEGlobal.hitbusScaler          = 0; // : 8; ???
    mod->FEConfig[number].FEGlobal.selfWidth             = m_data.getCfgEn()?readGlobRegister("SELF_WIDTH"):0;
    mod->FEConfig[number].FEGlobal.selfLatency           = m_data.getCfgEn()?readGlobRegister("SELF_LATENCY"):0;
    mod->FEConfig[number].FEGlobal.aregTrim              = m_data.getCfgEn()?1:0; // : 2;
    mod->FEConfig[number].FEGlobal.aregMeas              = 0; // : 2;
    mod->FEConfig[number].FEGlobal.dregTrim              = m_data.getCfgEn()?1:0; // : 2;
    mod->FEConfig[number].FEGlobal.dregMeas              = 0; // : 2;
    mod->FEConfig[number].FEGlobal.parity                = 0; // : 1;                
    mod->FEConfig[number].FEGlobal.enableHitParity       = 0; // : 1;                    
    mod->FEConfig[number].FEGlobal.enableHitbus          = m_data.getCfgEn()?readGlobRegister("ENABLE_HITBUS"):0;
    //mod->FEConfig[number].FEGlobal.monSpare              = 0; // : 1; ???                     
    mod->FEConfig[number].FEGlobal.enableAregMeas        = 0; // : 1;
    mod->FEConfig[number].FEGlobal.enableAreg            = 0; // : 1;
    mod->FEConfig[number].FEGlobal.enableLvdsRegMeas     = 0; // : 1; ???
    mod->FEConfig[number].FEGlobal.enableDregMeas        = 0; // : 1;
    mod->FEConfig[number].FEGlobal.enableTune            = m_data.getCfgEn()?readGlobRegister("ENABLE_AUTOTUNE"):0;
    mod->FEConfig[number].FEGlobal.enableBiasComp        = m_data.getCfgEn()?readGlobRegister("ENABLE_BIASCOMP"):0;
    mod->FEConfig[number].FEGlobal.enableIpMonitor       = 0; // : 1; ???
  } catch(PixFeExc &FeExc) {
    FeExc.dump(std::cout);
    throw PixFeExc(PixFeExc::INCOMPLETE_CONFIG, PixFeExc::ERROR, m_name);
  }
  
  // Copy FE pixel registers content
  ConfMask<bool> pixReg(m_structures.nCol(), m_structures.nRow(), 1);
  int i, row, col;
  
  UINT32* pixValue[4];
  std::string pixName[4];
  pixName[0]="ENABLE"; pixValue[0]=&(mod->FEConfig[number].FEMasks.maskEnable[0][0]);
  pixName[1]="SELECT"; pixValue[1]=&(mod->FEConfig[number].FEMasks.maskSelect[0][0]);
  pixName[2]="PREAMP"; pixValue[2]=&(mod->FEConfig[number].FEMasks.maskPreamp[0][0]);
  pixName[3]="HITBUS"; pixValue[3]=&(mod->FEConfig[number].FEMasks.maskHitbus[0][0]);

  for(int pixNum=0; pixNum<4; pixNum++) {
    try {
      pixReg = readPixRegister(pixName[pixNum]);
    } catch(PixFeExc &FeExc) {
      FeExc.dump(std::cout);
      throw PixFeExc(PixFeExc::INCOMPLETE_CONFIG, PixFeExc::ERROR, m_name);
    }
    for(col=0; col<m_structures.nCol(); col++)
      for(i=0; i<5; i++)
	*(pixValue[pixNum]+(i*m_structures.nCol() + col)) = 0;
    if(m_data.getCfgEn()){
      for(row=0; row<m_structures.nRow(); row++){
	for(col=0; col<m_structures.nCol(); col++){
	  //cout << std::dec << col << " " << row << " " << ((pixReg[col][row])?"ON ":"OFF ") << std::hex << ((UINT32)pixReg[col][row])<<(row%32) << endl;
	  *(pixValue[pixNum]+((row/32)*m_structures.nCol() + col)) |= ((UINT32)pixReg[col][row])<<(row%32);
	  //cout << std::hex << (*(pixValue[pixNum]+((row/32)*m_structures.nCol() + col))) << endl;
	}
      }
    }
  }
                  
  // Copy FE trim content
  ConfMask<unsigned short int> *trim;
                  
  UINT8* trimValue[2];
  std::string trimName[2];
  trimName[0]="TDAC"; trimValue[0]=&(mod->FEConfig[number].FETrims.dacThresholdTrim[0][0]);
  trimName[1]="FDAC"; trimValue[1]=&(mod->FEConfig[number].FETrims.dacFeedbackTrim[0][0]);

  for(int trimNum=0; trimNum<2; trimNum++) {
    try {
      int max;
      m_structures.getTrimMax("TDAC", max);
      trim = new ConfMask<unsigned short int>(m_structures.nCol(), m_structures.nRow(), max);
      (*trim) = readTrim(trimName[trimNum]);
    } catch(PixFeExc &FeExc) {
      FeExc.dump(std::cout);
      throw PixFeExc(PixFeExc::INCOMPLETE_CONFIG, PixFeExc::ERROR, m_name);
    }
    for(row=0; row<m_structures.nRow(); row++)
      for(col=0; col<m_structures.nCol(); col++)
	*(trimValue[trimNum]+(row*m_structures.nCol() + col)) = m_data.getCfgEn()?((*trim)[col][row]):0;
  }

  // Various stuff in the configuration structure
  mod->FEConfig[number].FEIndex = number; // fe index
  mod->FEConfig[number].FECommand.address = m_data.getCmdAddr(); // geographical address
  mod->FEConfig[number].FECalib.cinjLo = m_data.getCInjLo();
  mod->FEConfig[number].FECalib.cinjHi = m_data.getCInjHi();
  mod->FEConfig[number].FECalib.vcalCoeff[0] = m_data.getVcalGradient(0);
  mod->FEConfig[number].FECalib.vcalCoeff[1] = m_data.getVcalGradient(1);
  mod->FEConfig[number].FECalib.vcalCoeff[2] = m_data.getVcalGradient(2);
  mod->FEConfig[number].FECalib.vcalCoeff[3] = m_data.getVcalGradient(3);
  
  // Copy mask parameters
  mod->maskEnableFEConfig &= (~(0x1<<number));  mod->maskEnableFEConfig |= (m_data.getCfgEn()<<number);
  mod->maskEnableFEScan   &= (~(0x1<<number));  mod->maskEnableFEScan   |= (m_data.getScanEn()<<number);
  mod->maskEnableFEDacs   &= (~(0x1<<number));  mod->maskEnableFEDacs   |= (m_data.getDacsEn()<<number);
  
  // Copy Default value for dac during a DAC scan   
}