calib::XYZCalibProtoDUNE Class Reference

#include <XYZCalibProtoDUNE.h>

Inheritance diagram for calib::XYZCalibProtoDUNE:

Public Member Functions
	XYZCalibProtoDUNE ()
	XYZCalibProtoDUNE (fhicl::ParameterSet const &pset)
	XYZCalibProtoDUNE (XYZCalibProtoDUNE const &)=delete
virtual	~XYZCalibProtoDUNE ()=default
bool	Configure (fhicl::ParameterSet const &pset)
bool	Update (uint64_t ts=0)
virtual double	GetNormCorr (int plane) override
virtual double	GetXCorr (int plane, double x) override
virtual double	GetYZCorr (int plane, int side, double y, double z) override
void	SetIsMC (bool v)
void	SetNormCorr (int plane, double val)
void	SetXCorr (int plane, double x, double dx, double val)
void	SetYZCorr (int plane, int side, double y, double dx, double val)
void	SetUseCondb (bool v)
void	SetXCorrFileName (std::string f)
void	SetYZCorrFileName (std::string f)
void	SetNormCorrFileName (std::string f)
void	SetInterpolate (bool v)
Public Member Functions inherited from calib::XYZCalib
	XYZCalib (const XYZCalib &)=delete
	XYZCalib (XYZCalib &&)=delete
XYZCalib &	operator= (const XYZCalib &)=delete
XYZCalib &	operator= (XYZCalib &&)=delete
virtual	~XYZCalib ()=default

Protected Member Functions
bool	LoadNormCorr ()
bool	LoadXCorr ()
bool	LoadYZCorr ()
Protected Member Functions inherited from calib::XYZCalib
	XYZCalib ()=default

Protected Attributes
bool	fUseCondbXYZCorr
bool	fNormCorrLoaded
bool	fXCorrLoaded
bool	fYZCorrLoaded
bool	fIsMC
bool	fInterpolate
uint64_t	fCurrentTS
std::string	fXCorrFileName
std::string	fYZCorrFileName
std::string	fNormCorrFileName
std::string	fXCorrDBTag
std::string	fYZCorrDBTag
std::string	fNormCorrDBTag
std::map< int, NormCorr_t >	fNormCorr
std::map< int, TH1F >	fXCorrHist
std::map< int, TH2F >	fYZCorrHist

Detailed Description

Definition at line 64 of file XYZCalibProtoDUNE.h.

Constructor & Destructor Documentation

calib::XYZCalibProtoDUNE::XYZCalibProtoDUNE

(

)

Definition at line 29 of file XYZCalibProtoDUNE.cxx.

{
  fIsMC = true;
  fYZCorrLoaded = false;
  fXCorrLoaded = false;
  fNormCorrLoaded = false;
  fInterpolate = false;
  fCurrentTS = 0;
  fXCorrFileName="";
  fYZCorrFileName="";
  fNormCorrFileName="";
  fXCorrDBTag="";
  fYZCorrDBTag="";
  fNormCorrDBTag="";

}

calib::XYZCalibProtoDUNE::XYZCalibProtoDUNE

(

fhicl::ParameterSet const &

pset

)

Definition at line 48 of file XYZCalibProtoDUNE.cxx.

{
  fIsMC = true;
  fYZCorrLoaded = false;
  fXCorrLoaded = false;
  fNormCorrLoaded = false;
  fInterpolate = false;
  fCurrentTS = 0;
  fXCorrFileName="";
  fYZCorrFileName="";
  fNormCorrFileName="";
  fXCorrDBTag="";
  fYZCorrDBTag="";
  fNormCorrDBTag="";
  Configure(pset);
}

calib::XYZCalibProtoDUNE::XYZCalibProtoDUNE ( XYZCalibProtoDUNE const &  )

delete

virtual calib::XYZCalibProtoDUNE::~XYZCalibProtoDUNE ( )

virtualdefault

Member Function Documentation

bool calib::XYZCalibProtoDUNE::Configure

(

fhicl::ParameterSet const &

pset

)

Definition at line 68 of file XYZCalibProtoDUNE.cxx.

{  
  fIsMC            = pset.get<bool>("IsMC");
  fUseCondbXYZCorr = pset.get<bool>("UseCondbXYZCorr");
  fInterpolate     = pset.get<bool>("Interpolate");
  fXCorrFileName   = pset.get<std::string>("XCorrFileName");
  fYZCorrFileName  = pset.get<std::string>("YZCorrFileName");
  fNormCorrFileName= pset.get<std::string>("NormCorrFileName");
  fXCorrDBTag      = pset.get<std::string>("XCorrDBTag");
  fYZCorrDBTag     = pset.get<std::string>("YZCorrDBTag");
  fNormCorrDBTag   = pset.get<std::string>("NormCorrDBTag");
  return true;
}

double calib::XYZCalibProtoDUNE::GetNormCorr ( int  plane )

overridevirtual

Implements calib::XYZCalib.

Definition at line 108 of file XYZCalibProtoDUNE.cxx.

{
  if (!fNormCorrLoaded) this->LoadNormCorr();

  if (fNormCorr.find(chanId) == fNormCorr.end()) {
    mf::LogError("XYZCalibProtoDUNE") << "Plane not found!";
    return 0.;
  }

  return fNormCorr[chanId].corr;
}

double calib::XYZCalibProtoDUNE::GetXCorr ( int  plane, double  x  )

overridevirtual

Implements calib::XYZCalib.

Definition at line 121 of file XYZCalibProtoDUNE.cxx.

{
  if (!fXCorrLoaded) this->LoadXCorr();

  if (fXCorrHist.find(plane) == fXCorrHist.end()) {
    mf::LogError("XYZCalibProtoDUNE") << "Plane not found!";
    return 0.;
  }

  if (fInterpolate)
    return fXCorrHist[plane].Interpolate(x);
  else {
    int ix = fXCorrHist[plane].FindBin(x);
    return fXCorrHist[plane].GetBinContent(ix);
  }

}

double calib::XYZCalibProtoDUNE::GetYZCorr ( int  plane, int  side, double  y, double  z  )

overridevirtual

Implements calib::XYZCalib.

Definition at line 140 of file XYZCalibProtoDUNE.cxx.

{
  if (!fYZCorrLoaded) this->LoadYZCorr();

  int chanId = plane*10+side;

  if (fYZCorrHist.find(chanId) == fYZCorrHist.end()) {
    mf::LogError("XYZCalibProtoDUNE") << "Plane not found!";
    return 0.;
  }

  if (fInterpolate)
    return fYZCorrHist[chanId].Interpolate(z,y);
  else {
    int iz = fYZCorrHist[chanId].GetXaxis()->FindBin(z);
    int iy = fYZCorrHist[chanId].GetYaxis()->FindBin(y);
    return fYZCorrHist[chanId].GetBinContent(iz,iy);
  }
  
}

bool calib::XYZCalibProtoDUNE::LoadNormCorr ( )

protected

Definition at line 163 of file XYZCalibProtoDUNE.cxx.

{
  if (!fUseCondbXYZCorr) return true;

  if (fNormCorrLoaded) return true;

  nutools::dbi::Table NormCorrTable;
  
  NormCorrTable.SetDetector("pdunesp");
  NormCorrTable.SetTableName("distcorrnorm");
  NormCorrTable.SetTableType(nutools::dbi::kConditionsTable);
  NormCorrTable.SetDataTypeMask(nutools::dbi::kDataOnly);
  if (fIsMC)
    NormCorrTable.SetDataTypeMask(nutools::dbi::kMCOnly);
  
  int normIdx = NormCorrTable.AddCol("norm","double");
  int normErrIdx = NormCorrTable.AddCol("norm_err","double");
  
  NormCorrTable.SetMinTSVld(fCurrentTS);
  NormCorrTable.SetMaxTSVld(fCurrentTS);
  NormCorrTable.SetTag(fNormCorrDBTag);

  NormCorrTable.SetVerbosity(100);

  bool readOk = false;
  if (!fNormCorrFileName.empty()) 
    readOk = NormCorrTable.LoadFromCSV(fNormCorrFileName);
  else
    readOk = NormCorrTable.Load();

  if (! readOk) {
    mf::LogError("XYZCalibProtoDUNE") << "Load from norm calib database table failed.";
    
    return false; //std::abort();

  }
  
  if (NormCorrTable.NRow() == 0) {
    mf::LogError("XYZCalibProtoDUNE") << "Number of rows in norm calib table is 0.  This should never be the case!";
    return false;
  }
  
  nutools::dbi::Row* row;
  uint64_t chan;
  for (int i=0; i<NormCorrTable.NRow(); ++i) {
    NormCorr_t norm;
    row = NormCorrTable.GetRow(i);      
    chan = row->Channel();
    row->Col(normIdx).Get(norm.corr);
    row->Col(normErrIdx).Get(norm.corr_err);
    fNormCorr[chan] = norm;
  }    

  fNormCorrLoaded = true;
  return true;
}

bool calib::XYZCalibProtoDUNE::LoadXCorr ( )

protected

Definition at line 221 of file XYZCalibProtoDUNE.cxx.

{
  if (!fUseCondbXYZCorr) return true;

  if (fXCorrLoaded) return true;

  nutools::dbi::Table XCorrTable;
  
  XCorrTable.SetDetector("pdunesp");
  XCorrTable.SetTableName("distcorrx");
  XCorrTable.SetTableType(nutools::dbi::kConditionsTable);
  XCorrTable.SetDataTypeMask(nutools::dbi::kDataOnly);
  if (fIsMC)
    XCorrTable.SetDataTypeMask(nutools::dbi::kMCOnly);
  
  int shapeIdx = XCorrTable.AddCol("shape","double");
  int shapeErrIdx = XCorrTable.AddCol("shape_err","double");
  int xIdx = XCorrTable.AddCol("x","double");
  int dxIdx = XCorrTable.AddCol("dx","double");
  
  XCorrTable.SetMinTSVld(fCurrentTS);
  XCorrTable.SetMaxTSVld(fCurrentTS);
  XCorrTable.SetTag(fXCorrDBTag);
  
  XCorrTable.SetVerbosity(100);

  bool readOk = false;
  if (!fXCorrFileName.empty()) 
    readOk = XCorrTable.LoadFromCSV(fXCorrFileName);
  else
    readOk = XCorrTable.Load();

  if (! readOk) {
    mf::LogError("XYZCalibProtoDUNE") << "Load from x calib database table failed.";
    return false; //std::abort();
  }
  
  if (XCorrTable.NRow() == 0) {
    mf::LogError("XYZCalibProtoDUNE") << "Number of rows in x calib table is 0.  This should never be the case!";
    return false;
  }
  
  nutools::dbi::Row* row;
  uint64_t chan;
  int plane;
  std::vector<int> planeVec;

  std::map<int,std::vector<XCorr_t> > fXCorr;

  for (int i=0; i<XCorrTable.NRow(); ++i) {
    row = XCorrTable.GetRow(i);      
    chan = row->Channel();
    plane = int(chan/10000);

    XCorr_t xcorr;
    row->Col(xIdx).Get(xcorr.x);
    row->Col(dxIdx).Get(xcorr.dx);
    row->Col(shapeIdx).Get(xcorr.corr);
    row->Col(shapeErrIdx).Get(xcorr.corr_err);
    
    if (fXCorr.find(plane) == fXCorr.end()) {
      planeVec.push_back(plane);
      std::vector<XCorr_t> xcorrVec;
      fXCorr[plane] = xcorrVec;      
    }

    fXCorr[plane].push_back(xcorr);

  }    

  // sort the x-corrections by x for easy look-up
  for (unsigned int i=0; i<planeVec.size(); ++i) {
    int ip = planeVec[i];
    std::sort(fXCorr[ip].begin(),fXCorr[ip].end());
    char hname[256];
    sprintf(hname,"xCorrHist_%d",ip);
    int nbins = int(fXCorr[ip].size());
    double xmin = fXCorr[ip][0].x;
    double xmax = fXCorr[ip][nbins-1].x;
    double bw = (xmax-xmin)/(nbins-1);
    fXCorrHist[ip] = TH1F(hname,"",nbins,xmin-bw/2,xmax+bw/2);
    std::cout<<"fXcorrHist["<<ip<<"] binning: Nbins = "<<fXCorrHist[ip].GetNbinsX()<<" Xmin = "<<fXCorrHist[ip].GetXaxis()->GetXmin()<<" Xmax = "<<fXCorrHist[ip].GetXaxis()->GetXmax()<<std::endl;
    for (unsigned int j=0; j<fXCorr[ip].size(); ++j) 
      fXCorrHist[ip].SetBinContent(j+1,fXCorr[ip][j].corr);
  }
    
  fXCorrLoaded = true;
  return true;

}

bool calib::XYZCalibProtoDUNE::LoadYZCorr ( )

protected

Definition at line 313 of file XYZCalibProtoDUNE.cxx.

{
  if (!fUseCondbXYZCorr) return true;

  if (fYZCorrLoaded) return true;

  nutools::dbi::Table YZCorrTable;
  
  YZCorrTable.SetDetector("pdunesp");
  YZCorrTable.SetTableName("distcorryz");
  YZCorrTable.SetTableType(nutools::dbi::kConditionsTable);
  YZCorrTable.SetDataTypeMask(nutools::dbi::kDataOnly);
  if (fIsMC)
    YZCorrTable.SetDataTypeMask(nutools::dbi::kMCOnly);
  
  int corrIdx = YZCorrTable.AddCol("corr","double");
  int corrErrIdx = YZCorrTable.AddCol("corr_err","double");
  int yIdx = YZCorrTable.AddCol("y","double");
  //  int dyIdx = YZCorrTable.AddCol("dy","double");
  int zIdx = YZCorrTable.AddCol("z","double");
  //  int dzIdx = YZCorrTable.AddCol("dz","double");
  
  YZCorrTable.SetMinTSVld(fCurrentTS);
  YZCorrTable.SetMaxTSVld(fCurrentTS);
  YZCorrTable.SetTag(fYZCorrDBTag);

  YZCorrTable.SetVerbosity(100);

  bool readOk = false;
  if (!fYZCorrFileName.empty()) 
    readOk = YZCorrTable.LoadFromCSV(fYZCorrFileName);
  else
    readOk = YZCorrTable.Load();

  if (! readOk) {
    mf::LogError("XYZCalibProtoDUNE") << "Load from yz calib database table failed.";
    return false; //std::abort();
  }
  
  if (YZCorrTable.NRow() == 0) {
    mf::LogError("XYZCalibProtoDUNE") << "Number of rows in yz calib table is 0.  This should never be the case!";
    return false;
  }
  
  nutools::dbi::Row* row;
  uint64_t chan;
  std::vector<int> planeVec;

  std::map<int,std::vector<YZCorr_t> > fYZCorr;

  for (int i=0; i<YZCorrTable.NRow(); ++i) {
    row = YZCorrTable.GetRow(i);      
    chan = row->Channel();
    int plane = chan/10000000;
    int side = (chan-plane*10000000)/1000000;
    int chanId = plane*10+side;

    YZCorr_t yzcorr;
    row->Col(yIdx).Get(yzcorr.y);
    //    row->Col(dyIdx).Get(yzcorr.dy);
    row->Col(zIdx).Get(yzcorr.z);
    //    row->Col(dzIdx).Get(yzcorr.dz);
    row->Col(corrIdx).Get(yzcorr.corr);
    row->Col(corrErrIdx).Get(yzcorr.corr_err);

    if (fYZCorr.find(chanId) == fYZCorr.end()) 
      planeVec.push_back(chanId);

    fYZCorr[chanId].push_back(yzcorr);
    
  }    

  // sort the (y,z)-corrections by y and then by z for easy look-up
  int nbinsy=0;
  int nbinsz=0;
  double ymin=0.;
  double ymax=0.;
  double zmin=0;
  double zmax=0.;
  double bwy=0.;
  double bwz=0.;

  for (unsigned int i=0; i<planeVec.size(); ++i) {
    int ip = planeVec[i];
    std::sort(fYZCorr[ip].begin(),fYZCorr[ip].end());
    if (i==0) {
      ymin = fYZCorr[ip][0].y;
      zmin = fYZCorr[ip][0].z;
      ymax = fYZCorr[ip][fYZCorr[ip].size()-1].y;
      zmax = fYZCorr[ip][fYZCorr[ip].size()-1].z;
      // now figure out how many z bins there are
      for (unsigned j=1; j<fYZCorr[ip].size(); ++j, ++nbinsz) 
        if (fYZCorr[ip][j].z < fYZCorr[ip][j-1].z) break;
      nbinsy = int(fYZCorr[ip].size())/++nbinsz;
      bwz = (zmax-zmin)/(nbinsz-1);
      bwy = (ymax-ymin)/(nbinsy-1);
    }
    char hname[256];
    sprintf(hname,"yzCorrHist_%d",i);
    fYZCorrHist[ip] = TH2F(hname,"",nbinsz,zmin-bwz/2,zmax+bwz/2,
                           nbinsy,ymin-bwy/2,ymax+bwy/2);
    std::cout<<"fYZcorrHist["<<ip<<"] binning: Nbins = "<<fYZCorrHist[ip].GetNbinsX()<<" Xmin = "<<fYZCorrHist[ip].GetXaxis()->GetXmin()<<" Xmax = "<<fYZCorrHist[ip].GetXaxis()->GetXmax()<<" Ymin = "<<fYZCorrHist[ip].GetYaxis()->GetXmin()<<" Ymax = "<<fYZCorrHist[ip].GetYaxis()->GetXmax()<<std::endl;

    for (unsigned int j=0; j<fYZCorr[ip].size(); ++j) 
      fYZCorrHist[ip].Fill(fYZCorr[ip][j].z,fYZCorr[ip][j].y,fYZCorr[ip][j].corr);
  }
  
  fYZCorrLoaded = true;
  return true;

}

void calib::XYZCalibProtoDUNE::SetInterpolate ( bool  v )

inline

Definition at line 89 of file XYZCalibProtoDUNE.h.

{ fInterpolate = v; }

void calib::XYZCalibProtoDUNE::SetIsMC ( bool  v )

inline

Definition at line 80 of file XYZCalibProtoDUNE.h.

{ fIsMC = v; }

void calib::XYZCalibProtoDUNE::SetNormCorr	(	int	plane,
		double	val
	)

void calib::XYZCalibProtoDUNE::SetNormCorrFileName ( std::string  f )

inline

Definition at line 87 of file XYZCalibProtoDUNE.h.

{ fNormCorrFileName=f; }

void calib::XYZCalibProtoDUNE::SetUseCondb ( bool  v )

inline

Definition at line 84 of file XYZCalibProtoDUNE.h.

{ fUseCondbXYZCorr = v; }

void calib::XYZCalibProtoDUNE::SetXCorr	(	int	plane,
		double	x,
		double	dx,
		double	val
	)

void calib::XYZCalibProtoDUNE::SetXCorrFileName ( std::string  f )

inline

Definition at line 85 of file XYZCalibProtoDUNE.h.

{ fXCorrFileName=f; }

void calib::XYZCalibProtoDUNE::SetYZCorr	(	int	plane,
		int	side,
		double	y,
		double	dx,
		double	val
	)

void calib::XYZCalibProtoDUNE::SetYZCorrFileName ( std::string  f )

inline

Definition at line 86 of file XYZCalibProtoDUNE.h.

{ fYZCorrFileName=f; }

bool calib::XYZCalibProtoDUNE::Update

(

uint64_t

ts = 0

)

Definition at line 83 of file XYZCalibProtoDUNE.cxx.

{

  if (fYZCorrLoaded && ts != fCurrentTS) {
    fYZCorrHist.clear();
    fYZCorrLoaded = false;
  }

  if (fXCorrLoaded && ts != fCurrentTS) {
    fXCorrHist.clear();
    fXCorrLoaded = false;
  }

  if (fNormCorrLoaded && ts != fCurrentTS) {
    fNormCorr.clear();
    fNormCorrLoaded = false;
  }

  fCurrentTS = ts;
  // all done! 

  return true;
}

Member Data Documentation

uint64_t calib::XYZCalibProtoDUNE::fCurrentTS

protected

Definition at line 103 of file XYZCalibProtoDUNE.h.

bool calib::XYZCalibProtoDUNE::fInterpolate

protected

Definition at line 102 of file XYZCalibProtoDUNE.h.

bool calib::XYZCalibProtoDUNE::fIsMC

protected

Definition at line 101 of file XYZCalibProtoDUNE.h.

std::map<int,NormCorr_t> calib::XYZCalibProtoDUNE::fNormCorr

protected

Definition at line 112 of file XYZCalibProtoDUNE.h.

std::string calib::XYZCalibProtoDUNE::fNormCorrDBTag

protected

Definition at line 110 of file XYZCalibProtoDUNE.h.

std::string calib::XYZCalibProtoDUNE::fNormCorrFileName

protected

Definition at line 107 of file XYZCalibProtoDUNE.h.

bool calib::XYZCalibProtoDUNE::fNormCorrLoaded

protected

Definition at line 98 of file XYZCalibProtoDUNE.h.

bool calib::XYZCalibProtoDUNE::fUseCondbXYZCorr

protected

Definition at line 97 of file XYZCalibProtoDUNE.h.

std::string calib::XYZCalibProtoDUNE::fXCorrDBTag

protected

Definition at line 108 of file XYZCalibProtoDUNE.h.

std::string calib::XYZCalibProtoDUNE::fXCorrFileName

protected

Definition at line 105 of file XYZCalibProtoDUNE.h.

std::map<int,TH1F> calib::XYZCalibProtoDUNE::fXCorrHist

protected

Definition at line 113 of file XYZCalibProtoDUNE.h.

bool calib::XYZCalibProtoDUNE::fXCorrLoaded

protected

Definition at line 99 of file XYZCalibProtoDUNE.h.

std::string calib::XYZCalibProtoDUNE::fYZCorrDBTag

protected

Definition at line 109 of file XYZCalibProtoDUNE.h.

std::string calib::XYZCalibProtoDUNE::fYZCorrFileName

protected

Definition at line 106 of file XYZCalibProtoDUNE.h.

std::map<int,TH2F> calib::XYZCalibProtoDUNE::fYZCorrHist

protected

Definition at line 114 of file XYZCalibProtoDUNE.h.

bool calib::XYZCalibProtoDUNE::fYZCorrLoaded

protected

Definition at line 100 of file XYZCalibProtoDUNE.h.

---

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

• dunecalib/dunecalib/Calib/XYZCalibProtoDUNE.h
• dunecalib/dunecalib/Calib/XYZCalibProtoDUNE.cxx