/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/parser/MicrorocSCReader.cpp

Go to the documentation of this file.

/* @version $Revision: 1717 $ * @modifiedby $Author: gaglione $ * @lastmodified $Date: 2012-05-11 13:33:59 +0200 (Fri, 11 May 2012) $ */
#include "MicrorocSCReader.hh"
#include "Run.hh"
#include "Detector.hh"
#include "Chamber.hh"
#include "Dif.hh"
#include "Board.hh"
#include "Chip.hh"
#include "MicrorocChip.hh"
#include "MicrorocChannel.hh"
#include "MicroException.hh"
#include "tools/Log.hh"
#include "ilcConfDb/IlcConfDb.hh"

#include "configObjects/LdaConfiguration.h"
#include "configObjects/DccConfiguration.h"
#include "configObjects/AsicConfiguration.h"


#include <string>



using namespace std;

//-----------------------------oO0Oo--------------------
// Read SlowControl for one chip
MicrorocSCReader::MicrorocSCReader(Run& aRun, string& aData, ui16 difId)
: run(aRun), initialised(false),  bitsSize(0), bitsIndex(0)
{
  init(aData);
//  parseSC(difId);
}
//-----------------------------oO0Oo--------------------
MicrorocSCReader::MicrorocSCReader(Run& aRun, std::vector<int> aData, ui16 difId)
: run(aRun), initialised(false)  , bitsSize(0), bitsIndex(0)
{
  init(aData);
 // parseSC(difId);
  
}

MicrorocSCReader::MicrorocSCReader(Run& aRun)
: run(aRun), initialised(false) , bitsSize(0), bitsIndex(0)
{
}

//-----------------------------oO0Oo--------------------
MicrorocSCReader::~MicrorocSCReader() 

{
}



//----------------------------oO0Oo--------------------
void MicrorocSCReader::parseSCFromDb(IlcConfDb& ilcconf)
{
    try
    {
      AsicConfiguration& asicConf = ilcconf.getAsicConfiguration(run.getId() ) ;
      vector<ConfigObject*> asics = asicConf.getVector();
      for ( unsigned int i = 0 ; i <  asics.size() ; i++ )
      {
        int chipId, difId = 0;
        ui32 dac0, dac1 ,dac2 ,shaperLg ,shaperHg = 0;
        vector<int> pedestal_offset;
        string sstimulate, mask0, mask1, mask2;
        vector<bool> stimulate;
        try 
        {
          chipId = asics[i]->getInt("HEADER");
          difId = asics[i]->getInt("DIF_ID");
          dac0 =  asics[i]->getInt("BB0");
          dac1 =  asics[i]->getInt("BB1");
          dac2 =  asics[i]->getInt("BB2");
          shaperLg = asics[i]->getInt("SWLG");
          shaperHg = asics[i]->getInt("SWHG");
          pedestal_offset =  asics[i]->getIntVector("B0B3");
          sstimulate =  asics[i]->getString("CTEST");
          stimulate = convertCTEST(sstimulate);
          mask0 =  asics[i]->getString("MASK0");
          mask1 =  asics[i]->getString("MASK1");
          mask2 =  asics[i]->getString("MASK2");

          try {
            Dif& dif = run.getDetector().getDifById(difId);
            MicrorocChip &chip = dynamic_cast<MicrorocChip &> (dif.getChipById(chipId));

            chip.setShaper_lg(shaperLg);
            chip.setShaper_hg(shaperHg);
            chip.setThresholdDac_0(dac0);
            chip.setThresholdDac_1(dac1);
            chip.setThresholdDac_2(dac2);

            FILE_LOG(logDEBUG1) << "wanted[" << chipId << "] found chip[" << chip.getChipSoftId().toString()  <<endl;
            MicrorocChip &microChip = dynamic_cast<MicrorocChip &> (chip);
            microChip.setBypassed(false);  // if chip SC exist the chip is not bypassed
            microChip.setConfigured(true);
            for ( int channelNum = 0 ; channelNum <=63; channelNum++)
            {
              MicrorocChannel &microChannel = dynamic_cast<MicrorocChannel &> (microChip.getChannelById(channelNum));
              microChannel.setStimulate(stimulate[channelNum]);
              microChannel.setEnable(true);
              microChannel.setPedestalOffset(pedestal_offset[channelNum]);
            }
          }
          catch (MicroException& e)
          {
            FILE_LOG(logERROR) << "no chip with id[" << dec <<  chipId << "] for Dif[" << difId << "],  found " <<endl;
          }
          initialised = true;
        }
        catch  (Exception e){ } // Chip is not a microroc
      }
    }
    catch ( MicroException e ) {  FILE_LOG(logERROR) << e.getMessage(); } 
}
//----------------------------oO0Oo--------------------
void MicrorocSCReader::init(std::vector<int> vec )
{
  ostringstream oss;
  unsigned long data;
  initialised = true;
  
  for ( long i = 0 ; i < vec.size()     ;i++ )  // + 1 carcteres ascii ->  4 octets
  {
    {  // convertit caractere acsii en  uint hexa decimal
      data = vec[i];
      oss << bitset<8>(data);
      data = 0;
    }
  }

  bitset<592> b(oss.str());
  bits.push_back( b);


}
//-----------------------------oO0Oo--------------------
void MicrorocSCReader::init(string s )
{
  initialised = true;
        
  FILE_LOG(logDEBUG) << "Slow control init: s[" << s << "]"   <<endl;

  ui32 nbBits = s.size() * 4;
  ui32 nbCaraPerChip = 594 / 4 ;
  ui16 nbChips = nbBits / 592;
  
  for ( long j = 0 ; j  < nbChips   ;j++ )  // + 1 carcteres ascii ->  4 octets
  {
    ostringstream oss;
    unsigned long data;
    for ( long i = 0 ; i < nbCaraPerChip  ;i++ )  // + 1 carcteres ascii ->  4 octets
    {
        {  // convertit caractere acsii en  uint hexa decimal
            stringstream ss;
FILE_LOG(logDEBUG) << "j*nbCaraPerChip)+i[" << j*nbCaraPerChip+i << "] value[" <<  s.substr((j*nbCaraPerChip)+i,1) << "] " << endl;
            ss << s.substr((j*nbCaraPerChip)+i,1);
        
            ss >> hex >> data;
            oss << bitset<4>(data);
            data = 0;
        }
    }
    bitset<592> b(oss.str());
    FILE_LOG(logDEBUG) << "bitset for index[ " << bits.size() << "]: " << endl;
    FILE_LOG(logDEBUG) << "[" <<  oss.str() << "]: " << endl;
    bits.push_back(b);
  }


  FILE_LOG(logDEBUG) << "bits Size[" << bits.size() << "]"   <<endl;
}


//-----------------------------oO0Oo--------------------
void MicrorocSCReader::parseSC(ui16 difId)
{

    FILE_LOG(logINFO) << "MicrorocSCReader::parseSC sizeof bits[" <<bits.size() << "]" << endl;
// get chip then store its information
    Detector& detector = run.getDetector();
    bitsIndex= 0;

    for ( unsigned int index = 0; index <  bits.size() ; index++ )
    {
            ui16 chipId = getChipId();
            try {
        //          ChamberMap_t chambers = detector.getChambers();
        //          Chamber& chamber = *(chambers.begin()->second);

        //        ui16 chipId = getChipId();
                  Dif& dif = detector.getDifById(difId);
                  MicrorocChip &chip = dynamic_cast<MicrorocChip &> (dif.getChipById(chipId));

                  chip.setShaper_lg(getLowShaper());
                  chip.setShaper_hg(getHighShaper());
                  ui32 dac0 = getChipDac(0);
                  ui32 dac1 = getChipDac(1);
                  ui32 dac2 = getChipDac(2);
                  // en mode calibration les données DAC change dans le fichier mais pas de le SlowControl
                  if ( ! run.isCalibrationRun() )
                  {
                    chip.setThresholdDac_0(dac0);
                    chip.setThresholdDac_1(dac1);
                    chip.setThresholdDac_2(dac2);
                  }

                  FILE_LOG(logDEBUG1) << "wanted[" << chipId << "] found chip[" << chip.getChipSoftId().toString()  <<endl;
                                    MicrorocChip &microChip = dynamic_cast<MicrorocChip &> (chip);
                  microChip.setBypassed(false);  // if chip SC exist the chip is not bypassed
                  microChip.setConfigured(true);
                  //FILE_LOG(logINFO) << "chip Id[" << microChip.getId() << "], DAC 0[" << dac0 << "]" << endl;
                  //FILE_LOG(logINFO) << "chip Id[" << microChip.getId() << "], DAC 1[" << dac1 << "]" << endl;
                  //FILE_LOG(logINFO) << "chip Id[" << microChip.getId() << "], DAC 2[" << dac2 << "]" << endl;
              for ( int channelNum = 0 ; channelNum <=63; channelNum++)
                              {
                                      MicrorocChannel &microChannel = dynamic_cast<MicrorocChannel &> (microChip.getChannelById(channelNum));
                    ui16 dac = getChannelDac(channelNum);
                                      microChannel.setStimulate(true);
                                      microChannel.setEnable(true);
                                      microChannel.setPedestalOffset(dac);
                             }
            }
            catch (MicroException& e){
                  FILE_LOG(logERROR) << "no chip with id[" << dec <<  chipId << "] found " <<endl;
          }

        bitsIndex++;
        }
}

//-----------------------------oO0Oo--------------------
ui16  MicrorocSCReader::getBit(ui16 bitNum)const
{
        return bits[bitsIndex][bitNum-1];
}


//-----------------------------oO0Oo--------------------
ui16 MicrorocSCReader::getChipId() const
{
  ui16 result = getBit(chip_id) << 7;  // bit0
FILE_LOG(logDEBUG1) <<  "MicrorocSCReader::getChipId bit0[" << getBit(chip_id) << "]"  << endl;

  for ( ui16 bit = 1 ; bit <= 7 ; bit++)
  {
FILE_LOG(logDEBUG1) <<  "MicrorocSCReader::getChipId bit" << bit <<"[" <<  getBit(chip_id+bit) << "]"  << endl;
    result = result + ( getBit(chip_id+bit) << 7-bit ); 
  }

 return result;
}
//-----------------------------oO0Oo--------------------
ui16 MicrorocSCReader::getChannelDac(ui16 channelId ) const
{
  ui16 bit0Pos = dac_channel_pos + (channelId * dac_channel_nbits );
  ui16 bit0 = getBit(bit0Pos);
  ui16 bit1 = getBit(bit0Pos+1);
  ui16 bit2 = getBit(bit0Pos+2);
  ui16 bit3 = getBit(bit0Pos+3);


 return ( bit0 + bit1*2 + bit2 *4 + bit3*8 );
}
 
//-----------------------------oO0Oo--------------------
ui16 MicrorocSCReader::getLowShaper( ) const
{
        ui16 bit0 = getBit(low_shaper_bit_0);
        ui16 bit1 = getBit(low_shaper_bit_1);
        return bit0 + bit1*2;
}

//-----------------------------oO0Oo--------------------
ui16 MicrorocSCReader::getHighShaper( ) const
{
        ui16 bit0 = getBit(high_shaper_bit_0);
        ui16 bit1 = getBit(high_shaper_bit_1);
        return bit0 + bit1*2;
}

//-----------------------------oO0Oo--------------------
ui32 MicrorocSCReader::getChipDac( ui16 dac ) const
{

//complemant a 1 sur chaque bit.
// bit 9 est le bt de poids faible, le bit 0 est le bit de poids fort

  ui16 index = 0;
  if ( dac == 0 ) { index = chip_dac0; }
  else if ( dac == 1 ) { index = chip_dac1; }
  else if ( dac == 2 ) { index = chip_dac2; }
  else {  FILE_LOG(logINFO) << "dac"<< dac << " does not exist" << endl; exit(-1) ;   }

        ui16 bit0 = !getBit(index);
        ui16 bit1 = !getBit(index+1);
        ui16 bit2 = !getBit(index+2);
        ui16 bit3 = !getBit(index+3);
        ui16 bit4 = !getBit(index+4);
        ui16 bit5 = !getBit(index+5);
        ui16 bit6 = !getBit(index+6);
        ui16 bit7 = !getBit(index+7);
        ui16 bit8 = !getBit(index+8);
        ui16 bit9 = !getBit(index+9);


  ui32 result =  bit9 + bit8*2 + bit7*4 + bit6*8 + bit5*16 + bit4*32 + bit3*64 + bit2*128 + bit1*256 + bit0*512 ;

    
  return result;
}
//-----------------------------oO0Oo--------------------
vector<bool>  MicrorocSCReader::convertCTEST(string chaine)
{
vector<bool> result ;
  // chainbe format:   "0XCCCCCCCCCCCCCCCC"   with C from 0 to F
  chaine.substr(chaine.find("0X")+2 , chaine.length()-2);
//chaine = "0X0F";

string svalue = chaine.substr(chaine.find("0X")+2 , chaine.length()-2);


unsigned long int x;
stringstream ss;
ss << std::hex << svalue;
ss >> x;

for ( unsigned int i = 0 ; i< 16 ; i++ )
{
  unsigned int foo = (x & 0xf) ;
  x = x >> 4;
  for ( unsigned int j = 0 ; j < 4 ; j++ )
  {
    bool bit = foo & 0x1 ;
    foo = foo >> 1;
    result.push_back(bit);
  }

}

  

return result;
}

---