PixelCalib::PixelOfflineCalibData Class Reference

#include <PixelOfflineCalibData.h>

Collaboration diagram for PixelCalib::PixelOfflineCalibData:

Public Member Functions
	PixelOfflineCalibData ()
	Constructor:
	PixelOfflineCalibData (const PixelOfflineCalibData &rhs)=delete
PixelOfflineCalibData &	operator= (const PixelOfflineCalibData &rhs)=delete
	~PixelOfflineCalibData ()
	default destructor
bool	update (const PixelClusterErrorData &idat)
bool	update (const PixelChargeInterpolationParameters &idat)
bool	update (const PixelClusterOnTrackErrorData &idat)
int	size () const
PixelClusterErrorData *	getPixelClusterErrorData ()
PixelChargeInterpolationParameters *	getPixelChargeInterpolationParameters ()
PixelClusterOnTrackErrorData *	getPixelClusterOnTrackErrorData ()
const PixelClusterErrorData *	getPixelClusterErrorData () const
const PixelChargeInterpolationParameters *	getPixelChargeInterpolationParameters () const
const PixelClusterOnTrackErrorData *	getPixelClusterOnTrackErrorData () const
int	GetNumberOfConstants () const
std::vector< float >	GetConstants () const
void	SetConstants (const std::vector< float > &constants)
void	Dump ()

Private Attributes
PixelClusterErrorData *	m_clustererrordata
PixelChargeInterpolationParameters *	m_chargeinterpolationparameters
PixelClusterOnTrackErrorData *	m_clusterontrackerrordata

Detailed Description

Definition at line 31 of file PixelOfflineCalibData.h.

Constructor & Destructor Documentation

PixelOfflineCalibData() [1/2]

PixelOfflineCalibData::PixelOfflineCalibData ( )

inline

Constructor:

Definition at line 73 of file PixelOfflineCalibData.h.

                                                    {
  m_clustererrordata = new PixelClusterErrorData();
  m_clusterontrackerrordata = new PixelClusterOnTrackErrorData();
  m_chargeinterpolationparameters = new PixelChargeInterpolationParameters();
} 

PixelOfflineCalibData() [2/2]

PixelCalib::PixelOfflineCalibData::PixelOfflineCalibData ( const PixelOfflineCalibData & rhs )

delete

~PixelOfflineCalibData()

PixelOfflineCalibData::~PixelOfflineCalibData ( )

inline

default destructor

Definition at line 125 of file PixelOfflineCalibData.h.

                                                    {
delete m_clustererrordata;
delete m_chargeinterpolationparameters;
delete m_clusterontrackerrordata;
}

Member Function Documentation

Dump()

void PixelOfflineCalibData::Dump

(

)

Definition at line 158 of file PixelOfflineCalibData.cxx.

                                {
  m_clustererrordata->Print("PixelClusterDump.txt");
  m_clusterontrackerrordata->Print("PixelClusterOnTrackDump.txt");
  m_chargeinterpolationparameters->Print("PixelChargeInterpolationParametersDump.txt");
}

GetConstants()

std::vector< float > PixelOfflineCalibData::GetConstants

(

)

const

Definition at line 15 of file PixelOfflineCalibData.cxx.

                                                           { 
 
  // format version of parametrizations (note it is an increasing NEGATIVE number)
  int v1 = m_clustererrordata->getVersion(); 
  int v2 = m_clusterontrackerrordata->getVersion(); 
  int v3 = m_chargeinterpolationparameters->getVersion(); 
 
  int n1 = m_clustererrordata->getNumberOfBarrelBins(); 
  int n2 = m_clustererrordata->getNumberOfEndcapBins();
  // get the bins of the cluster on track error data parametrization 
  const std::vector<float> &csx = m_clusterontrackerrordata->getClusterSizeBinsX();
  const std::vector<float> &csy = m_clusterontrackerrordata->getClusterSizeBinsY();
  const std::vector<float> &eta = m_clusterontrackerrordata->getEtaBins();
  const std::vector<float> &alpha = m_clusterontrackerrordata->getIncidenceAngleBins();
  //IBL
  const std::vector<float> &etaibl = m_clusterontrackerrordata->getEtaIBLBins();
  const std::vector<float> &alphaibl = m_clusterontrackerrordata->getIncidenceAngleIBLBins();
  //
  // number of bins 
  // Since the upper value is always implicit, numer of bins is the size of the vector
  int ncsx = csx.size();
  int ncsy = csy.size();
  int neta = eta.size();
  int nalpha = alpha.size();
  int ncsx_ibl = m_clusterontrackerrordata->getIBLcsxbins();
  int ncsy_ibl = m_clusterontrackerrordata->getIBLcsybins();
  int netaibl = m_clusterontrackerrordata->getIBLetabins();
  int nalphaibl =m_clusterontrackerrordata->getIBLphibins(); 
  // get the bins of the charge interpolation parametrization 
  const std::vector<float> &csx2 = m_chargeinterpolationparameters->getClusterSizeXBins();
  const std::vector<float> &csy2 = m_chargeinterpolationparameters->getClusterSizeYBins();
  const std::vector<float> &eta2 = m_chargeinterpolationparameters->getEtaBins();
  const std::vector<float> &alpha2 = m_chargeinterpolationparameters->getAngleBins();
  // IBL
  const std::vector<float> &etaibl2 =  m_chargeinterpolationparameters->getIBLEtaBins() ;
  const std::vector<float> &alphaibl2 = m_chargeinterpolationparameters->getIBLAngleBins() ;
  //
  // number of bins
  // The upper limit is not implicit, we must subtract one!
  int ncsx2 = csx2.size()-1;
  int ncsy2 = csy2.size()-1;
  int neta2 = eta2.size()-1;
  int nalpha2 = alpha2.size()-1;
  int ncsx2_ibl = m_chargeinterpolationparameters->getIBLcsxbins();
  int ncsy2_ibl = m_chargeinterpolationparameters->getIBLcsybins();
  int netaibl2 =m_chargeinterpolationparameters->getIBLetabins(); 
  int nalphaibl2 = m_chargeinterpolationparameters->getIBLphibins();
 
  // Compute the overall number of values to store
 
  int n3a = ncsx*nalpha; // ClusterErrorOnTrack - number of barrel phi bins
  int n3b = ncsx*ncsy*neta; // ClusterErrorOnTrack - number of barrel eta bins
  int n3c = ncsx_ibl*nalphaibl;
  int n3d = ncsy_ibl*netaibl;
  int n4 = 6*ncsx2*nalpha2; // ChargeInterpolation - number of barrel phi bins
  int n5 = 6*ncsy2*neta2; // ChargeInterpolation - number of barrel eta bins
  int n6 = ncsx2_ibl*nalphaibl2;
  int n7 = ncsy2_ibl*netaibl2;
  int datasize = 
    2*n1+2*n2  // number of ClusterError values
    +ncsx+ncsy+neta+nalpha // number of ClusterErrorOnTrack bin extremes values
    +n3a+n3b // number of ClusterErrorOnTrack values
    +ncsx2+1+ncsy2+1+neta2+1+nalpha2+1 // number of ChargeInterpolation bin extremes values
    +n4+n5; // number of ChargeInterpolation values
 
  int offset = 13;
  if(v1<-1||v2<-1||v3<-1) { // including IBL
    offset +=8;
    datasize +=2*n1 + netaibl+1 + nalphaibl+1 + n3c +n3d + netaibl2+1 + nalphaibl2+1 + n6 + n7;
  }
 
  std::vector<float> constants;
  constants.reserve(datasize+offset);
  constants.push_back(v1);
  constants.push_back(v2);
  constants.push_back(v3); 
  constants.push_back(n1);
  constants.push_back(n2);
  constants.push_back(ncsx);
  constants.push_back(ncsy);
  constants.push_back(neta);
  constants.push_back(nalpha);
  constants.push_back(ncsx2);
  constants.push_back(ncsy2);
  constants.push_back(neta2);
  constants.push_back(nalpha2);
  if(offset>13){
    constants.push_back(ncsx_ibl);
    constants.push_back(ncsx_ibl); 
    constants.push_back(netaibl);
    constants.push_back(nalphaibl);
    constants.push_back(ncsx2_ibl);
    constants.push_back(ncsy2_ibl); 
    constants.push_back(netaibl2);
    constants.push_back(nalphaibl2);
  }
 
  // set bins of cluster error on track parametrization (uppermost value implicit)
  for(int i=0; i<ncsx; i++){ constants.push_back(csx[i]); }
  for(int i=0; i<ncsy; i++){ constants.push_back(csy[i]); }
  if(netaibl>0){
    for(int i=0; i<netaibl+1; i++){ constants.push_back(etaibl[i]); }
  }
  if(nalphaibl>0){
    for(int i=0; i<nalphaibl+1; i++){ constants.push_back(alphaibl[i]); }
  }
  for(int i=0; i<neta; i++){ constants.push_back(eta[i]); }
  for(int i=0; i<nalpha; i++){ constants.push_back(alpha[i]); }
  // set bins of charge interpolation parametrization (uppermost value stored)
  for(int i=0; i<ncsx2+1; i++){ constants.push_back(csx2[i]); }
  for(int i=0; i<ncsy2+1; i++){ constants.push_back(csy2[i]); }
  if(netaibl2>0){
    for(int i=0; i<netaibl2+1; i++){ constants.push_back(etaibl2[i]); }
  }
  if(nalphaibl2>0){
    for(int i=0; i<nalphaibl2+1; i++){ constants.push_back(alphaibl2[i]); }
  }
  for(int i=0; i<neta2+1; i++){ constants.push_back(eta2[i]); }
  for(int i=0; i<nalpha2+1; i++){ constants.push_back(alpha2[i]); }
  // parametrization values
  for(int i=0; i<n1; i++){ constants.push_back(m_clustererrordata->getPixelBarrelPhiError(i)); }
  for(int i=0; i<n1; i++){ constants.push_back(m_clustererrordata->getPixelBarrelEtaError(i)); }
  for(int i=0; i<n2; i++){ constants.push_back(m_clustererrordata->getPixelEndcapPhiError(i)); }
  for(int i=0; i<n2; i++){ constants.push_back(m_clustererrordata->getPixelEndcapRError(i)); }
  // IBL
  if(v1<-1){
    for(int i=0; i<n1; i++){ constants.push_back(m_clustererrordata->getPixelIBLPhiError(i)); }
    for(int i=0; i<n1; i++){ constants.push_back(m_clustererrordata->getPixelIBLEtaError(i)); }
  }
  //IBL
  if(n3c>0){ 
    for(int i=0; i<n3c; i++){ constants.push_back(m_clusterontrackerrordata->getPixelIBLPhiError(i)); }
  }
  for(int i=0; i<n3a; i++){ constants.push_back(m_clusterontrackerrordata->getPixelBarrelPhiError(i)); }
  if(n3d>0){
    for(int i=0; i<n3d; i++){ constants.push_back(m_clusterontrackerrordata->getPixelIBLEtaError(i)); }
  }
  for(int i=0; i<n3b; i++){ constants.push_back(m_clusterontrackerrordata->getPixelBarrelEtaError(i)); }
  for(int i=0; i<n6+n4; i++){ constants.push_back(m_chargeinterpolationparameters->getDeltaX(i)); }
  for(int i=0; i<n7+n5; i++){ constants.push_back(m_chargeinterpolationparameters->getDeltaY(i)); }
  return constants;
}

GetNumberOfConstants()

int PixelCalib::PixelOfflineCalibData::GetNumberOfConstants

(

)

const

getPixelChargeInterpolationParameters() [1/2]

PixelChargeInterpolationParameters * PixelOfflineCalibData::getPixelChargeInterpolationParameters ( )

inline

Definition at line 101 of file PixelOfflineCalibData.h.

                                                                                                        {
  return m_chargeinterpolationparameters;
}

getPixelChargeInterpolationParameters() [2/2]

const PixelChargeInterpolationParameters * PixelOfflineCalibData::getPixelChargeInterpolationParameters ( ) const

inline

Definition at line 114 of file PixelOfflineCalibData.h.

                                                                                                                    {
  return m_chargeinterpolationparameters;
}

getPixelClusterErrorData() [1/2]

PixelClusterErrorData * PixelOfflineCalibData::getPixelClusterErrorData ( )

inline

Definition at line 97 of file PixelOfflineCalibData.h.

                                                                              {
  return m_clustererrordata;
}

getPixelClusterErrorData() [2/2]

const PixelClusterErrorData * PixelOfflineCalibData::getPixelClusterErrorData ( ) const

inline

Definition at line 110 of file PixelOfflineCalibData.h.

                                                                                          {
  return m_clustererrordata;
}

getPixelClusterOnTrackErrorData() [1/2]

PixelClusterOnTrackErrorData * PixelOfflineCalibData::getPixelClusterOnTrackErrorData ( )

inline

Definition at line 106 of file PixelOfflineCalibData.h.

                                                           {
  return m_clusterontrackerrordata;
}

getPixelClusterOnTrackErrorData() [2/2]

const PixelClusterOnTrackErrorData * PixelOfflineCalibData::getPixelClusterOnTrackErrorData ( ) const

inline

Definition at line 119 of file PixelOfflineCalibData.h.

                                                                 {
  return m_clusterontrackerrordata;
}

operator=()

PixelOfflineCalibData & PixelCalib::PixelOfflineCalibData::operator= ( const PixelOfflineCalibData & rhs )

delete

SetConstants()

void PixelOfflineCalibData::SetConstants

(

const std::vector< float > &

constants

)

Definition at line 164 of file PixelOfflineCalibData.cxx.

                                                                         { 
 
  if(constants.at(0) > 0){    // old format
    m_clustererrordata->setVersion(0);
    m_clusterontrackerrordata->setVersion(0);
    m_chargeinterpolationparameters->setVersion(0);
 
    const int n1 = int(constants.at(0)); // number of PixelClusterError barrel bins (60)
    const int n2 = int(constants.at(1)); // number of PixelClusterError endcap bins (12)
    const int ncsx = int(constants.at(2)); // number of PixelClusterOnTrackError cluster size bins (x direction)
    const int ncsy = int(constants.at(3)); // number of PixelClusterOnTrackError cluster size bins (y direction)
    const int neta = int(constants.at(4)); // number of PixelClusterOnTrackError eta bins (x direction)
    const int nalpha = int(constants.at(5)); // number of PixelClusterOnTrackError incidence angle bins (y direction)
    const int n4 = int(constants.at(6)); // number of charge interpolation constants (x direction)
    const int n5 = int(constants.at(7)); // number of charge interpolation constants (y direction)
    int ierr = 1; // error code
    int offset = 8;
    m_clusterontrackerrordata->setParameters(ncsx,ncsy,neta,nalpha,offset,constants);
    offset += ncsx+ncsy+neta+nalpha;
    for(int i=0; i<n1; i++){
      ierr *= m_clustererrordata->setPixelBarrelPhiError(i,constants.at(i+offset));
      ierr *= m_clustererrordata->setPixelBarrelEtaError(i,constants.at(i+n1+offset));
    }
    offset += 2*n1;
    for(int i=0; i<n2; i++){
      ierr *= m_clustererrordata->setPixelEndcapPhiError(i,constants.at(offset+i));
      ierr *= m_clustererrordata->setPixelEndcapRError(i,constants.at(offset+n2+i));
    }
    offset += 2*n2;
    int n3a = ncsx*nalpha; // number of barrel phi bins
    int n3b = ncsx*ncsy*neta; // number of barrel eta bins
    for(int i=0; i<n3a; i++){
      m_clusterontrackerrordata->setPixelBarrelPhiError(i,constants.at(offset+i));
    }
    offset += n3a;
    for(int i=0; i<n3b; i++){
      m_clusterontrackerrordata->setPixelBarrelEtaError(i,constants.at(offset+i));
    }
    offset += n3b;
    for(int i=0; i<n4; i++){
      ierr *= m_chargeinterpolationparameters->setDeltaX(i,constants.at(offset+i));
    }
    offset += n4;
    for(int i=0; i<n5; i++){
      ierr *= m_chargeinterpolationparameters->setDeltaY(i,constants.at(offset+i));
    }
    m_chargeinterpolationparameters->setVersion(-1);
    if(ierr == 0) std::cout << "something went wrong!" << std::endl;
    return;
 
  }
  else{ 
 
    const int v1 = int(constants.at(0)); // format version number for PixelClusterError
    const int v2 = int(constants.at(1)); // format version number for PixelClusterOnTrackError
    const int v3 = int(constants.at(2)); // format version number for PixelChargeInterpolation
    m_clustererrordata->setVersion(v1);
    m_clusterontrackerrordata->setVersion(v2);
    m_chargeinterpolationparameters->setVersion(v3);
 
    const int n1 = int(constants.at(3)); // number of PixelClusterError barrel bins (60)
    const int n2 = int(constants.at(4)); // number of PixelClusterError endcap bins (12)
    const int ncsx = int(constants.at(5)); // number of PixelClusterOnTrackError cluster size bins (x direction)
    const int ncsy = int(constants.at(6)); // number of PixelClusterOnTrackError cluster size bins (y direction)
    const int neta = int(constants.at(7)); // number of PixelClusterOnTrackError eta bins (x direction)
    const int nalpha = int(constants.at(8)); // number of PixelClusterOnTrackError incidence angle bins (y direction)
    const int ncsx2 = int(constants.at(9)); // number of PixelClusterOnTrackError cluster size bins (x direction)
    const int ncsy2 = int(constants.at(10)); // number of PixelClusterOnTrackError cluster size bins (y direction)
    const int neta2 = int(constants.at(11)); // number of PixelClusterOnTrackError eta bins (x direction)
    const int nalpha2 = int(constants.at(12)); // number of PixelClusterOnTrackError incidence angle bins (y direction)
    int ierr = 1; // error code
    int offset = 13;
    if(v1<-1||v2<-1||v3<-1)offset +=8; 
    const int ncsx_ibl = offset>13 ? int(constants.at(13)) : 0;
    const int ncsy_ibl = offset>13 ? int(constants.at(14)) : 0;
    const int netaibl = offset>13 ? int(constants.at(15)) : 0;
    const int nalphaibl = offset>13 ? int(constants.at(16)) : 0;
    const int ncsx2_ibl = offset>13 ? int(constants.at(17)) : 0;
    const int ncsy2_ibl = offset>13 ? int(constants.at(18)) : 0;
    const int netaibl2 = offset>13 ? int(constants.at(19)) : 0;
    const int nalphaibl2 = offset>13 ? int(constants.at(20)) : 0;
    if(v2<-1){
      m_clusterontrackerrordata->setIBLcsxbins(ncsx_ibl);
      m_clusterontrackerrordata->setIBLcsybins(ncsy_ibl);
      m_clusterontrackerrordata->setIBLetabins(netaibl);
      m_clusterontrackerrordata->setIBLphibins(nalphaibl);
    }
    m_clusterontrackerrordata->setParameters(ncsx,ncsy,neta,nalpha,offset,constants);
    offset += ncsx+ncsy+neta+nalpha; // check that offset is advanced or not 
    if(v2<-1) offset +=netaibl+1+nalphaibl+1; 
    if(v3<-1){
      m_chargeinterpolationparameters->setIBLcsxbins(ncsx2_ibl);
      m_chargeinterpolationparameters->setIBLcsybins(ncsy2_ibl);
      m_chargeinterpolationparameters->setIBLetabins(netaibl2);
      m_chargeinterpolationparameters->setIBLphibins(nalphaibl2);
    }
 
    m_chargeinterpolationparameters->setParameters(ncsx2,ncsy2,neta2,nalpha2,offset,constants);
    offset += (ncsx2+1)+(ncsy2+1)+(neta2+1)+(nalpha2+1);
    if(v3<-1) offset += (netaibl2+1) + (nalphaibl2+1);
    for(int i=0; i<n1; i++){
      ierr *= m_clustererrordata->setPixelBarrelPhiError(i,constants.at(i+offset));
      ierr *= m_clustererrordata->setPixelBarrelEtaError(i,constants.at(i+n1+offset));
    }
    offset += 2*n1;
    for(int i=0; i<n2; i++){
      ierr *= m_clustererrordata->setPixelEndcapPhiError(i,constants.at(offset+i));
      ierr *= m_clustererrordata->setPixelEndcapRError(i,constants.at(offset+n2+i));
    }
    offset += 2*n2;
    if(v1<-1){
      for(int i=0; i<n1; i++){
        ierr *= m_clustererrordata->setPixelIBLPhiError(i,constants.at(i+offset));
        ierr *= m_clustererrordata->setPixelIBLEtaError(i,constants.at(i+n1+offset));
      }
      offset +=2*n1;
    }
    int n3a = ncsx*nalpha; // number of barrel phi bins
    int n3b = ncsx*ncsy*neta; // number of barrel eta bins
    int n3c = ncsx_ibl*nalphaibl;
    int n3d = ncsy_ibl*netaibl;
    if(n3c>0){
      for(int i=0; i<n3c; i++){
        m_clusterontrackerrordata->setPixelIBLPhiError(i,constants.at(offset+i));
      }
      offset += n3c;
    }
    for(int i=0; i<n3a; i++){
      m_clusterontrackerrordata->setPixelBarrelPhiError(i,constants.at(offset+i));
    }
    offset += n3a;
 
    if(n3d>0){
      for(int i=0; i<n3d; i++){
        m_clusterontrackerrordata->setPixelIBLEtaError(i,constants.at(offset+i));
      }
      offset += n3d;
    }
 
    for(int i=0; i<n3b; i++){
      m_clusterontrackerrordata->setPixelBarrelEtaError(i,constants.at(offset+i));
    }
    offset += n3b;
    const int n4 = 6*ncsx2*nalpha2; // number of charge interpolation constants (x direction)
    const int n5 = 6*ncsy2*neta2; // number of charge interpolation constants (y direction)
    const int n6 = ncsx2_ibl*nalphaibl2;
    const int n7 = ncsy2_ibl*netaibl2;
 
    for(int i=0; i<n6+n4; i++){
      ierr *= m_chargeinterpolationparameters->setDeltaX(i,constants.at(offset+i));
    }
    offset += n6+n4;
    for(int i=0; i<n7+n5; i++){
      ierr *= m_chargeinterpolationparameters->setDeltaY(i,constants.at(offset+i));
    }
    offset += n7+n5;
 
    if(ierr == 0) std::cout << "something went wrong!" << std::endl;
    return;
  }
}

size()

int PixelCalib::PixelOfflineCalibData::size

(

)

const

update() [1/3]

bool PixelOfflineCalibData::update ( const PixelChargeInterpolationParameters & idat )

inline

Definition at line 86 of file PixelOfflineCalibData.h.

                                                 {
  *m_chargeinterpolationparameters = idat;
  return true;
}

update() [2/3]

bool PixelOfflineCalibData::update ( const PixelClusterErrorData & idat )

inline

Definition at line 81 of file PixelOfflineCalibData.h.

                                                                          {
  *m_clustererrordata = idat;
  return true;
}

update() [3/3]

bool PixelOfflineCalibData::update ( const PixelClusterOnTrackErrorData & idat )

inline

Definition at line 92 of file PixelOfflineCalibData.h.

                                                                                 {
  *m_clusterontrackerrordata = idat;
  return true;
}

Member Data Documentation

m_chargeinterpolationparameters

PixelChargeInterpolationParameters* PixelCalib::PixelOfflineCalibData::m_chargeinterpolationparameters

private

Definition at line 67 of file PixelOfflineCalibData.h.

m_clustererrordata

PixelClusterErrorData* PixelCalib::PixelOfflineCalibData::m_clustererrordata

private

Definition at line 66 of file PixelOfflineCalibData.h.

m_clusterontrackerrordata

PixelClusterOnTrackErrorData* PixelCalib::PixelOfflineCalibData::m_clusterontrackerrordata

private

Definition at line 68 of file PixelOfflineCalibData.h.

---

The documentation for this class was generated from the following files:

• PixelOfflineCalibData.h
• PixelOfflineCalibData.cxx