TileOFC.h File Reference

#include <vector>

Include dependency graph for TileOFC.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	Double2Int_calib (double calib_constant, unsigned int &scale, unsigned int &offset, bool verbose=false)
void	Double2Int_ofc (int w_off_size, const std::vector< double > &w_off, std::vector< int > &w_dsp, int &w_sum_dsp, int &scale, bool verbose=false)
bool	ConvertOFC (const std::vector< std::vector< std::vector< std::vector< double > > > > &w_off, const std::vector< std::vector< double > > &calibration, int calibtype, int runtype, std::vector< unsigned int > &OFC, bool verbose=false)
bool	Format6 (const std::vector< double > &a, const std::vector< double > &b, const std::vector< double > &c, const std::vector< double > &g, const std::vector< double > &h, unsigned int index_channel, int phase, double calibration, std::vector< unsigned int > &OFC, bool verbose=false)
	Format6.
bool	Format5 (const std::vector< double > &a, const std::vector< double > &b, const std::vector< double > &c, const std::vector< double > &g, const std::vector< double > &h, std::vector< unsigned int > &OFC, bool verbose=false)
	Format5.
bool	Format5calib (double calib, std::vector< unsigned int > &OFC, bool verbose=false)
bool	FormatInfo (int nsamples, int calibrationtype, int algorithm, int runtype, std::vector< unsigned int > &OFC, bool verbose=false)
bool	ReadOFfile (std::vector< std::vector< std::vector< std::vector< double > > > > &w_off, char *OFCfile, bool verbose=false)

Function Documentation

ConvertOFC()

bool ConvertOFC	(	const std::vector< std::vector< std::vector< std::vector< double > > > > &	w_off,
		const std::vector< std::vector< double > > &	calibration,
		int	calibtype,
		int	runtype,
		std::vector< unsigned int > &	OFC,
		bool	verbose = false )

Definition at line 88 of file TileOFC.cxx.

                                                         {
  bool flag;
  
  // Select number of phases and step inside DSP
  //int format = 5;
  //format = format;
  float dsp_step = 1. ;
  float dsp_min_phase = -100.;
  float dsp_max_phase = -dsp_min_phase;
  int   dsp_phases    = (int) roundf( (dsp_max_phase - dsp_min_phase)*(1./dsp_step) +1. );
  
  if (1)
    {
      cout<<"----- DSP -----"<<endl;
      cout<<"Step: "<<dsp_step<<" ns"<<endl;
      cout<<"Min Phase: "<<dsp_min_phase<<" ns"<<endl;
      cout<<"Max Phase: "<<dsp_max_phase<<" ns"<<endl;
      cout<<"Nb phases: "<<dsp_phases<<endl;
    }
 
  // Number of phases and step of the offline Opt. filte constants
  const float off_step = 0.1;
  float off_min_phase = -100.;
  float off_max_phase = -off_min_phase;
  int   off_phases    = (int) roundf( (off_max_phase - off_min_phase)*(1./off_step) + 1. );
  if (verbose)
    {
      cout<<"----- OFFLINE -----"<<endl;
      cout<<"Step: "<<off_step<<" ns"<<endl;
      cout<<"Min Phase: "<<off_min_phase<<" ns"<<endl;
      cout<<"Max Phase: "<<off_max_phase<<" ns"<<endl;
      cout<<"Nb phases: "<<off_phases<<endl;
    }
 
  int ngains   = (int) w_off.size();
  int nphases  = (int) w_off[0].size();
  int nparams  = (int) w_off[0][0].size();
  int nsamples = (int) w_off[0][0][0].size();
  
  if ( dsp_step < off_step ){
    cout<<"ERROR: DSP phase step smaller than Offline phase step"<<endl;
    return false;
  }
  if (ngains != 2){
    cout<<"ERROR: Incorrect number of gains"<<endl;
    return false;
  }
  if (off_phases != nphases){
    cout<<"ERROR: Incorrect number of phases"<<endl;
    return false;
  }
  if (dsp_min_phase < off_min_phase){
    cout<<"ERROR: Incorrect minimum phase"<<endl;
    return false;
  }
  if (dsp_max_phase > off_max_phase){
    cout<<"ERROR: Incorrecto maximum phase"<<endl;
    return false;
  }
  
  int algorithm;
  if (nparams == 3){
    algorithm = 0; // OF1
  }else if (nparams == 4){
    algorithm = 1; // OF2
  }else{
    cout<<"ERROR: Incorrect algorithm type"<<endl;
    return false;
  }
 
  // Get Calibration
  int ig;
  int calib_gain = (int) calibration.size();
  int calib_size = (int) calibration[0].size();
  if (calib_gain!=ngains){
    cout<<"ERROR: Number of gain in calibration vector incorrect"<<endl;
    return false;
  }
  vector<double> calibration_lo;
  vector<double> calibration_hi;
  for (int i=0; i<calib_size; i++)
    {
      ig = 0; // low gain
      calibration_lo.push_back( calibration[ig][i] );
      ig = 1; // high gain
      calibration_hi.push_back( calibration[ig][i] );
    }
  if (calibtype != 0) calibration_hi[1] = calibration_hi[1]*64.;
  
  if (verbose)
    {
      cout<<"--- calibration ---"<<endl;
      cout<<"[low  gain] -> offset: "<<calibration_lo[0]<<"  slope: "<<calibration_lo[1]<<endl; 
      cout<<"[high gain] -> offset: "<<calibration_hi[0]<<"  slope: "<<calibration_hi[1]<<endl; 
      cout<<"If calibtype != ADC then slope is multiplied by a factor 64"<<endl;
    }
  
  // Get Optimal filtering constants
  vector<double> a_lo(nsamples,0);
  vector<double> b_lo(nsamples,0);
  vector<double> c_lo(nsamples,0);
  vector<double> g_lo(nsamples,0);
  vector<double> h_lo(nsamples,0);
  vector<double> a_hi(nsamples,0);
  vector<double> b_hi(nsamples,0);
  vector<double> c_hi(nsamples,0);
  vector<double> g_hi(nsamples,0);
  vector<double> h_hi(nsamples,0);
  
  // Select phases for the DSP
  int index;
  float current_phase;
 
  // bln
  const float inv_off_step = 1. / off_step;
  for (int i=0; i<dsp_phases; i++){
    
    current_phase = dsp_min_phase + i*dsp_step;
    index = (int) roundf((current_phase - off_min_phase)*inv_off_step);
    if (verbose) cout<<"["<<index<<"]: Phase "<<current_phase<<" ns"<<endl;
    for (int is=0; is<nsamples; is++)
      {
    ig = 0; // low gain
    a_lo[is] = w_off[ig][index][0][is];
    b_lo[is] = w_off[ig][index][1][is];
    g_lo[is] = w_off[ig][index][nparams-1][is];
    // missing c_lo, h_lo
 
    ig = 1; // high gain
    a_hi[is] = w_off[ig][index][0][is];
    b_hi[is] = w_off[ig][index][1][is];
    g_hi[is] = w_off[ig][index][nparams-1][is];
    // missing c_hi, h_hi
    
      }
    
    
    // convert Format5
    if (verbose) cout<<"---- LOW GAIN ----"<<endl;
    flag = Format5( a_lo, b_lo, c_lo, g_lo, h_lo, OFC, verbose); 
    if (!flag) return flag;
    if (verbose) cout<<"---- HIGH GAIN ----"<<endl;
    flag = Format5( a_hi, b_hi, c_hi, g_hi, h_hi, OFC, verbose); 
    if (!flag) return flag;
   
  }
 
  cout << "ERROR!!! Format 5 in this call is incomplete (OFC::ConvertOFC)" << endl;
 
  flag = FormatInfo( nsamples, calibtype, algorithm, runtype, OFC, verbose);
  if (!flag) return flag;
    
  a_lo.clear();
  b_lo.clear();
  g_lo.clear();
  a_hi.clear();
  b_hi.clear();
  g_hi.clear();
  calibration_lo.clear();
  calibration_hi.clear();
 
  return true;
}

Double2Int_calib()

void Double2Int_calib	(	double	calib_constant,
		unsigned int &	scale,
		unsigned int &	offset,
		bool	verbose = false )

Definition at line 18 of file TileOFC.cxx.

{
  // Number of bits of the integer word (signed -1 )
  int NumberBits = 16;
  NumberBits = NumberBits - 1;
  
  // Get Scale
  scale = 0;
  double max = fabs(calib);
  if (max!=0) scale = (unsigned int) truncf(log((pow(2.,NumberBits)-1.)/max)*(1./log(2.)));
  
  // Convert to integer 
  offset = (unsigned int) roundf(calib*pow(2.,(int)scale));
  
  if (verbose) cout << "Calib = " << hex << calib 
            << " ==> ( scale: " << scale 
            << " , offset: " << offset 
            << ")" << dec << endl;
  
}

Double2Int_ofc()

void Double2Int_ofc	(	int	w_off_size,
		const std::vector< double > &	w_off,
		std::vector< int > &	w_dsp,
		int &	w_sum_dsp,
		int &	scale,
		bool	verbose = false )

Definition at line 41 of file TileOFC.cxx.

{
  // Number of bits of the integer word (signed -1 )
  int NumberBits = 16;
  NumberBits = NumberBits - 1;
  
  // Get Absolute Maximum
  double max = -10000.;
  double sum = 0.;
  for (int i=0; i<w_off_size; i++)
    {
      sum += w_off[i]; 
      if ( fabs(w_off[i]) > max ) max = fabs(w_off[i]);
    }
  if (fabs(sum) > max) max = fabs(sum);
  
  // Get Scale at Maximum
  scale = 0;
  if (max!=0) scale = (int) truncf(log((pow(2.,NumberBits)-1.)/max)*(1./log(2.)));
  
  // Convert to Integer the weights and the sum
  for (int i=0; i<w_off_size; i++)  w_dsp.push_back( (int) roundf(w_off[i]*pow(2.,scale)) );
  w_sum_dsp = (int) roundf(sum*pow(2.,scale));
  
 
  if (verbose) {
    printf("\nAbsolute Max value = %15.8f -> Scale = %3d\n",max,scale);
 
    for (int i=0; i<w_off_size; i++)
      {
        if ( i == 0){
          printf("\n        Offline              Off*Scale             Dsp/scale    Dsp      Scale  \n");
          printf("----------------------------------------------------------------------------------\n");
          printf("  %17.10f     %17.10f    %17.10f  0x%04X    %3d   \n",
         w_off[i],w_off[i]*pow(2.,scale), w_dsp[i]/pow(2.,scale),(unsigned int) w_dsp[i] ,scale);
        } else {
          printf("  %17.10f     %17.10f    %17.10f  0x%04X   \n",
         w_off[i],w_off[i]*pow(2.,scale),w_dsp[i]/pow(2.,scale),(unsigned int)w_dsp[i]);
        }
      }
    printf("  %17.10f     %17.10f    %17.10f  0x%04X     <- SUM\n",
       sum,sum*pow(2.,scale),w_sum_dsp/pow(2.,scale),(unsigned int)w_sum_dsp);
  }
  
  return ;
}

Format5()

bool Format5	(	const vector< double > &	a,
		const vector< double > &	b,
		const vector< double > &	c,
		const vector< double > &	g,
		const vector< double > &	h,
		vector< unsigned int > &	OFC,
		bool	verbose )

Format5.

Format used in the OFW with iterations

Parameters

a	vector of A weights to compute energy
b	vector of B weights to compute phase
c	vector of C weights to compute pedestal
g	vector of G weights to compute QF
h	vector of derivative of G weights to compute QF
OFC	reference to OFW vector
verbose	boolean value

Returns

bool true on success

Definition at line 359 of file TileOFC.cxx.

{
  vector<int> adsp;
  vector<int> bdsp;
  vector<int> cdsp;
  vector<int> gdsp;
  vector<int> hdsp;
  
  int asum;
  int bsum;
  int dump;
 
  int ascale;
  int bscale;
  int cscale;
  int gscale;
  int hscale;
 
  Double2Int_ofc( (int) a.size(), a, adsp, asum, ascale, verbose );
  Double2Int_ofc( (int) b.size(), b, bdsp, bsum, bscale, verbose );
  Double2Int_ofc( (int) c.size(), c, cdsp, dump, cscale, verbose );
  Double2Int_ofc( (int) g.size(), g, gdsp, dump, gscale, verbose );
  Double2Int_ofc( (int) h.size(), h, hdsp, dump, hscale, verbose );
 
  // Start formating
  int n_2 = (int) trunc(a.size()/2.);
 
  for (int i=0; i<n_2; i++)
    OFC.push_back( ( (adsp[2*i] << 16 )& 0xFFFF0000) | ( adsp[2*i+1] & 0x0000FFFF) ) ;
  OFC.push_back( ( (adsp[2*n_2] << 16 )& 0xFFFF0000) | ( (-asum) & 0x0000FFFF) );
 
  for (int i=0; i<n_2; i++)
    OFC.push_back( ( (bdsp[2*i] << 16 )& 0xFFFF0000) | ( bdsp[2*i+1] & 0x0000FFFF) ) ;
  OFC.push_back( ( (bdsp[2*n_2] << 16 )& 0xFFFF0000) | ( (-bsum) & 0x0000FFFF) );
  
  OFC.push_back( ( (bscale  << 16 )& 0xFFFF0000) | ( ascale   & 0x0000FFFF) );
  
  OFC.push_back( ( (cdsp[0] << 16 )& 0xFFFF0000) | ( cscale   & 0x0000FFFF) );
  for (int i=1; i<=n_2; i++)
    OFC.push_back( ( (cdsp[2*i] << 16 )& 0xFFFF0000) | ( cdsp[2*i-1] & 0x0000FFFF) ) ;
  
  OFC.push_back( ( (hscale  << 16 )& 0xFFFF0000) | ( gscale   & 0x0000FFFF) );
  for (size_t i=0; i<g.size();i++)
    OFC.push_back( ( (hdsp[i] << 16 )& 0xFFFF0000) | ( gdsp[i] & 0x0000FFFF) );
  
  adsp.clear();
  bdsp.clear();
  cdsp.clear();
  gdsp.clear();
  hdsp.clear();
  
  if (verbose) cout<<"size of OFC: "<<OFC.size()<<endl;
  return true;
  
}

Format5calib()

bool Format5calib	(	double	calib,
		std::vector< unsigned int > &	OFC,
		bool	verbose = false )

Definition at line 421 of file TileOFC.cxx.

                                                                          {
  
  unsigned int offset_scale = 0;
  unsigned int offset = 0;
  
  unsigned int slope_scale;
  unsigned int slope;
 
  Double2Int_calib( calib, slope_scale, slope, verbose );
  
  OFC.push_back( ( (offset_scale << 16) & 0xFFFF0000) | ( slope_scale & 0x0000FFFF) );
  OFC.push_back( ( (offset       << 16) & 0xFFFF0000) | ( slope       & 0x0000FFFF) );
 
  return true;
} 

Format6()

bool Format6	(	const std::vector< double > &	a,
		const std::vector< double > &	b,
		const std::vector< double > &	c,
		const std::vector< double > &	g,
		const std::vector< double > &	h,
		unsigned int	channel_index,
		int	phase,
		double	calibration,
		std::vector< unsigned int > &	OFC,
		bool	verbose )

Format6.

Format used in the OFW without iterations

Parameters

a	vector of A weights to compute energy
b	vector of B weights to compute phase
c	vector of C weights to compute pedestal
g	vector of G weights to compute QF
h	vector of derivative of G weights to compute QF
channel_index	channel index [0:48]
phase	rounded scaled integer value of the channel's best phase
calibration	calibration factor to be applied to the energy
OFC	reference to OFW vector
verbose	boolean value

Returns

bool true on success

Definition at line 270 of file TileOFC.cxx.

{
  vector<int> adsp;
  vector<int> bdsp;
  vector<int> cdsp;
  vector<int> gdsp;
  vector<int> hdsp;
  
  int dump;
 
  int ascale;
  int bscale;
  int cscale;
  int gscale;
  int hscale;
 
  Double2Int_ofc( (int) a.size(), a, adsp, dump, ascale, verbose );
  Double2Int_ofc( (int) b.size(), b, bdsp, dump, bscale, verbose );
  Double2Int_ofc( (int) c.size(), c, cdsp, dump, cscale, verbose );
  Double2Int_ofc( (int) g.size(), g, gdsp, dump, gscale, verbose );
  Double2Int_ofc( (int) h.size(), h, hdsp, dump, hscale, verbose );
 
  unsigned int slope_scale;
  unsigned int slope;
  
  Double2Int_calib( calibration, slope_scale, slope, verbose );
 
  // Start formating
  int n_2 = (int) trunc(a.size()/2.);
 
  // OFC for energy
  OFC.push_back( ( (adsp[0] << 16) & 0xFFFF0000) | ( (ascale-1) & 0xFFFF)   );
  for (int i=1; i<=n_2; i++)
    OFC.push_back( ( (adsp[2*i] << 16) & 0xFFFF0000) | ( adsp[2*i-1] & 0xFFFF) );
 
  // Calibration
  OFC.push_back( ( (slope     << 16) & 0xFFFF0000) | ( (ascale + slope_scale ) & 0xFFFF ) );
 
  // OFC for phase
  OFC.push_back( ( (bdsp[0] << 16) & 0xFFFF0000) | ( (bscale-4) & 0xFFFF)   );
  for (int i=1; i<=n_2; i++)
    OFC.push_back( ( (bdsp[2*i] << 16) & 0xFFFF0000) | ( bdsp[2*i-1] & 0xFFFF) );
 
  // OFC for pedestal
  OFC.push_back( ( (cdsp[0] << 16) & 0xFFFF0000) | ( (cscale) & 0xFFFF)   );
  for (int i=1; i<=n_2; i++)
    OFC.push_back( ( (cdsp[2*i] << 16) & 0xFFFF0000) | ( cdsp[2*i-1] & 0xFFFF) );
  
  // OFC for quality factor
  OFC.push_back( ( (hscale << 16) & 0xFFFF0000) | ( (gscale+1) & 0xFFFF)   );
  for (size_t i=0; i<g.size(); i++)
    OFC.push_back( ( (hdsp[i] << 16) & 0xFFFF0000) | ( gdsp[i] & 0xFFFF) );
 
  // codificar index channel y fase
  OFC.push_back( ( (channel_index << 16) & 0xFFFF0000) | (phase & 0xFFFF) ) ;
 
  if (verbose) cout<<"size of OFC: "<<OFC.size()<<endl;
 
  adsp.clear();
  bdsp.clear();
  cdsp.clear();
  gdsp.clear();
  hdsp.clear();
 
  return true;
}

FormatInfo()

bool FormatInfo	(	int	nsamples,
		int	calibrationtype,
		int	algorithm,
		int	runtype,
		std::vector< unsigned int > &	OFC,
		bool	verbose = false )

Definition at line 437 of file TileOFC.cxx.

{
  int in = 1;
  if (nsamples == 9){
    in = 1;
  }else if(nsamples == 7){
    in = 0;
  }else {
    cout<<"ERROR: [FormatInfo] Incorrect number of samples"<<endl;
    return false;
  }
 
  if (calibrationtype > 3 || calibrationtype < 0 ) {
    cout<<"ERROR: [FormatInfo] Unknown calibration type"<<endl;
    return false;
  }
 
  // poner lo mismo con runtype
 
  if (algorithm != 0 && algorithm!=1){
    cout<<"ERROR: [FormatInfo] Unknown algorithm type"<<endl;
    return false;
  }
  
  OFC.push_back( ((calibrationtype & 0x3)<<6) | ((runtype & 0x3)<<4) | ((in & 0x1)<<3) | ((algorithm & 0x1) << 2) );
  
  if (verbose) printf("OFC info: 0x%08x\n", ((calibrationtype & 0x3)<<6) | ((runtype & 0x3)<<4) | ((in & 0x1)<<3) | ((algorithm & 0x1) << 2) );
 
  return true;
}

ReadOFfile()

bool ReadOFfile	(	std::vector< std::vector< std::vector< std::vector< double > > > > &	w_off,
		char *	OFCfile,
		bool	verbose = false )

Definition at line 468 of file TileOFC.cxx.

{
  // OPEN FILE
  ifstream fin;
  fin.open(OFCfile, ios::in);
  if (!fin.is_open())
    {
      cout<<"Error opening file "<<(OFCfile)<<endl;
      return false;
    }
 
  // input file settings
  float f_samples = 9;     // 9 samples
  float f_phi     = -100;  // ns  (-100,100) ns
  float f_step    = 0.1;
  int nphases = (int) roundf(-f_phi*2./f_step + 1.);
  int ngains = 2;
  int nsamples = (int) roundf(f_samples);
 
  // get number of parameters
  string s;
  double tmp1;
  int nparams=0;
  getline(fin,s);
  istringstream ss(s);
  while (ss >> tmp1) {
    nparams++;
  }
  cout<<"Number of parameters: "<<nparams<<endl;
  
  // Resize w_off vector
  w_off.resize(ngains);
  for (int ig=0; ig<ngains; ig++){
    w_off[ig].resize(nphases);
    for (int it=0; it<nphases; it++){
      w_off[ig][it].resize(nparams);
      for (int ip=0; ip<nparams; ip++){
        w_off[ig][it][ip].resize(nsamples,0);
      }
    }
  }
  fin.close();
 
  // read file
  fin.open(OFCfile, ios::in);
  for (int it=0; it<nphases; it++)
    {
      for (int is=0; is<nsamples; is++)
    {
      for (int ig=0; ig<ngains; ig++)
        {
          int ip = 0;
          getline(fin,s);
          istringstream ss(s);
          while (ss >> tmp1) {
        w_off[ig][it][ip][is] = tmp1;
        ip++;
          }
        }
    }      
    }
 
  verbose = true;
  if (verbose)
    {
      cout<<"Optimal Filtering file: "<<(OFCfile)<<endl;
      cout<<"Nb phases:  "<<w_off[0].size()<<endl;
      cout<<"Nb samples: "<<w_off[0][0][0].size()<<endl;
      cout<<"Nb gains:   "<<w_off.size()<<endl;
      if ((int) w_off[0][0].size() == 3 ) cout<<"Algorithm: OF1"<<endl;
      else if ((int) w_off[0][0].size() == 4 ) cout<<"Algorithm: OF2"<<endl;
    }
  
  // CLOSE FILE
  fin.close();
  
  return true;
}