#include <CastorPedestalAnalysis.h>

Public Member Functions
	CastorPedestalAnalysis (const edm::ParameterSet &ps)
	Constructor.
int	done (const CastorPedestals fInputPedestals, const CastorPedestalWidths fInputWidths, CastorPedestals fOutputPedestals, CastorPedestalWidths fOutputWidths)
void	processEvent (const CastorDigiCollection &castor, const CastorDbService &cond)
void	SampleAnalysis ()
void	setup (const std::string &m_outputFileROOT)
	~CastorPedestalAnalysis ()
	Destructor.
Static Public Member Functions
static int	CastorPedVal (int nstat[4], const CastorPedestals fRefPedestals, const CastorPedestalWidths fRefPedestalWidths, CastorPedestals fRawPedestals, CastorPedestalWidths fRawPedestalWidths, CastorPedestals fValPedestals, CastorPedestalWidths fValPedestalWidths)
Private Types
typedef std::pair< TH1F , std::pair< std::map< int, std::vector< double > >, std::vector< TH1F > > >	PEDBUNCH
Private Member Functions
void	AllChanHists (const HcalDetId detid, const HcalQIESample &qie0, const HcalQIESample &qie1, const HcalQIESample &qie2, const HcalQIESample &qie3, const HcalQIESample &qie4, const HcalQIESample &qie5, std::map< HcalDetId, std::map< int, PEDBUNCH > > &toolT)
void	GetPedConst (std::map< HcalDetId, std::map< int, PEDBUNCH > > &toolT, TH1F PedMeans, TH1F PedWidths)
void	per2CapsHists (int flag, int id, const HcalDetId detid, const HcalQIESample &qie1, const HcalQIESample &qie2, std::map< HcalDetId, std::map< int, PEDBUNCH > > &toolT, const CastorDbService &cond)
void	Trendings (std::map< HcalDetId, std::map< int, PEDBUNCH > > &toolT, TH1F Chi2, TH1F CapidAverage, TH1F *CapidChi2)
Private Attributes
std::map< HcalDetId, std::map < int, PEDBUNCH > >::iterator	_meot
struct {
TH1F * ALLPEDS
TH1F * CAPID_AVERAGE
TH1F * CAPID_CHI2
TH1F * CHI2
TH1F * PEDMEAN
TH1F * PEDRMS
std::map< HcalDetId, std::map < int, PEDBUNCH > > PEDTRENDS
}	castorHists
int	evt
int	evt_curr
CastorPedestals *	fRawPedestals
CastorPedestalWidths *	fRawPedestalWidths
const CastorPedestals *	fRefPedestals
const CastorPedestalWidths *	fRefPedestalWidths
CastorPedestals *	fValPedestals
CastorPedestalWidths *	fValPedestalWidths
int	m_AllPedsOK
const CastorQIECoder *	m_coder
int	m_endTS
TFile *	m_file
int	m_hiSaveflag
std::ofstream	m_logFile
int	m_nevtsample
std::string	m_outputFileMean
std::string	m_outputFileROOT
std::string	m_outputFileWidth
int	m_pedsinADC
int	m_pedValflag
const CastorQIEShape *	m_shape
int	m_startTS
float	m_stat [4]
int	sample
std::vector< bool >	state
Static Private Attributes
static const int	fitflag = 0

Detailed Description

Definition at line 39 of file CastorPedestalAnalysis.h.

Member Typedef Documentation

typedef std::pair<TH1F*,std::pair<std::map<int, std::vector<double> >,std::vector<TH1F*> > > CastorPedestalAnalysis::PEDBUNCH [private]

Definition at line 89 of file CastorPedestalAnalysis.h.

Constructor & Destructor Documentation

CastorPedestalAnalysis::CastorPedestalAnalysis ( const edm::ParameterSet & ps )

Constructor.

Definition at line 15 of file CastorPedestalAnalysis.cc.

References castorHists, gather_cfg::cout, evt, edm::ParameterSet::getUntrackedParameter(), i, gen::k, m_AllPedsOK, m_endTS, m_file, m_hiSaveflag, m_nevtsample, m_outputFileMean, m_outputFileROOT, m_outputFileWidth, m_pedsinADC, m_pedValflag, m_startTS, m_stat, and sample.

  : fRefPedestals (0),
    fRefPedestalWidths (0),
    fRawPedestals (0),
    fRawPedestalWidths (0),
    fValPedestals (0),
    fValPedestalWidths (0)
{
  evt=0;
  sample=0;
  m_file=0;
  m_AllPedsOK=0;
  for(int i=0; i<4; i++) m_stat[i]=0;
  for(int k=0;k<4;k++) state.push_back(true);

// user cfg parameters
  m_outputFileMean = ps.getUntrackedParameter<string>("outputFileMeans", "");
  if ( m_outputFileMean.size() != 0 ) {
    cout << "Castor pedestal means will be saved to " << m_outputFileMean.c_str() << endl;
  } 
  m_outputFileWidth = ps.getUntrackedParameter<string>("outputFileWidths", "");
  if ( m_outputFileWidth.size() != 0 ) {
    cout << "Castor pedestal widths will be saved to " << m_outputFileWidth.c_str() << endl;
  } 
  m_outputFileROOT = ps.getUntrackedParameter<string>("outputFileHist", "");
  if ( m_outputFileROOT.size() != 0 ) {
    cout << "Castor pedestal histograms will be saved to " << m_outputFileROOT.c_str() << endl;
  } 
  m_nevtsample = ps.getUntrackedParameter<int>("nevtsample",0);
// for compatibility with previous versions
  if(m_nevtsample==9999999) m_nevtsample=0;
  m_pedsinADC = ps.getUntrackedParameter<int>("pedsinADC",0);
  m_hiSaveflag = ps.getUntrackedParameter<int>("hiSaveflag",0);
  m_pedValflag = ps.getUntrackedParameter<int>("pedValflag",0);
  if(m_pedValflag<0) m_pedValflag=0;
  if (m_nevtsample>0 && m_pedValflag>0) {
    cout<<"WARNING - incompatible cfg options: nevtsample = "<<m_nevtsample<<", pedValflag = "<<m_pedValflag<<endl;
    cout<<"Setting pedValflag = 0"<<endl;
    m_pedValflag=0;
  }
  if(m_pedValflag>1) m_pedValflag=1;
  m_startTS = ps.getUntrackedParameter<int>("firstTS", 0);
  if(m_startTS<0) m_startTS=0;
  m_endTS = ps.getUntrackedParameter<int>("lastTS", 9);

//  m_logFile.open("CastorPedestalAnalysis.log");

  castorHists.ALLPEDS = new TH1F("Castor All Pedestals","HF All Peds",10,0,9);
  castorHists.PEDRMS= new TH1F("Castor All Pedestal Widths","HF All Pedestal RMS",100,0,3);
  castorHists.PEDMEAN= new TH1F("Castor All Pedestal Means","HF All Pedestal Means",100,0,9);
  castorHists.CHI2= new TH1F("Castor Chi2/ndf for whole range Gauss fit","HF Chi2/ndf Gauss",200,0.,50.);
}

CastorPedestalAnalysis::~CastorPedestalAnalysis ( )

Destructor.

Definition at line 69 of file CastorPedestalAnalysis.cc.

References _meot, castorHists, and i.

                                               {

  for(_meot=castorHists.PEDTRENDS.begin(); _meot!=castorHists.PEDTRENDS.end(); _meot++){
    for(int i=0; i<16; i++) _meot->second[i].first->Delete();
  }

  castorHists.ALLPEDS->Delete();
  castorHists.PEDRMS->Delete();
  castorHists.PEDMEAN->Delete();
  castorHists.CHI2->Delete();
}

Member Function Documentation

void CastorPedestalAnalysis::AllChanHists	(	const HcalDetId	detid,
		const HcalQIESample &	qie0,
		const HcalQIESample &	qie1,
		const HcalQIESample &	qie2,
		const HcalQIESample &	qie3,
		const HcalQIESample &	qie4,
		const HcalQIESample &	qie5,
		std::map< HcalDetId, std::map< int, PEDBUNCH > > &	toolT
	)		`[private]`

Referenced by processEvent().

int CastorPedestalAnalysis::CastorPedVal	(	int	nstat[4],
		const CastorPedestals *	fRefPedestals,
		const CastorPedestalWidths *	fRefPedestalWidths,
		CastorPedestals *	fRawPedestals,
		CastorPedestalWidths *	fRawPedestalWidths,
		CastorPedestals *	fValPedestals,
		CastorPedestalWidths *	fValPedestalWidths
	)		`[static]`

Definition at line 644 of file CastorPedestalAnalysis.cc.

References CastorCondObjectContainer< Item >::addValues(), benchmark_cfg::cerr, cond::rpcobgas::detid, CastorCondObjectContainer< Item >::getAllChannels(), CastorPedestalWidth::getSigma(), CastorPedestal::getValue(), CastorCondObjectContainer< Item >::getValues(), HcalForward, i, CastorPedestalWidth::setSigma(), mathSSE::sqrt(), and tablePrinter::width.

Referenced by done().

{
// new version of pedestal validation - it is designed to be as independent of
// all the rest as possible - you only need to provide valid pedestal objects
// and a vector of statistics per capID to use this as standalone code
  HcalDetId detid;
  float RefPedVals[4]; float RefPedSigs[4][4];
  float RawPedVals[4]; float RawPedSigs[4][4];
  map<HcalDetId,bool> isinRaw;
  map<HcalDetId,bool> isinRef;
  std::vector<DetId> RefChanns=fRefPedestals->getAllChannels();
  std::vector<DetId> RawChanns=fRawPedestals->getAllChannels();
  std::ofstream PedValLog;
  PedValLog.open("CastorPedVal.log");

  if(nstat[0]+nstat[1]+nstat[2]+nstat[3]<2500) PedValLog<<"CastorPedVal: warning - low statistics"<<std::endl;
// find complete list of channels in current data and reference
  for (int i=0; i<(int)RawChanns.size(); i++){
    isinRef[HcalDetId(RawChanns[i])]=false;
  }
  for (int i=0; i<(int)RefChanns.size(); i++){
    detid=HcalDetId(RefChanns[i]);
    isinRaw[detid]=false;
    isinRef[detid]=true;
  }
  for (int i=0; i<(int)RawChanns.size(); i++){
    detid=HcalDetId(RawChanns[i]);
    isinRaw[detid]=true;
    if (isinRef[detid]==false) {
      PedValLog<<"CastorPedVal: channel "<<detid<<" not found in reference set"<<std::endl;
      std::cerr<<"CastorPedVal: channel "<<detid<<" not found in reference set"<<std::endl;
    }
  }

// main loop over channels
  int erflag=0;
  for (int i=0; i<(int)RefChanns.size(); i++){
    detid=HcalDetId(RefChanns[i]);
    for (int icap=0; icap<4; icap++) {
      RefPedVals[icap]=fRefPedestals->getValues(detid)->getValue(icap);
      for (int icap2=icap; icap2<4; icap2++) {
        RefPedSigs[icap][icap2]=fRefPedestalWidths->getValues(detid)->getSigma(icap,icap2);
        if(icap2!=icap)RefPedSigs[icap2][icap]=RefPedSigs[icap][icap2];
      }
    }

// read new raw values
    if(isinRaw[detid]) {
      for (int icap=0; icap<4; icap++) {
        RawPedVals[icap]=fRawPedestals->getValues(detid)->getValue(icap);
        for (int icap2=icap; icap2<4; icap2++) {
          RawPedSigs[icap][icap2]=fRawPedestalWidths->getValues(detid)->getSigma(icap,icap2);
          if(icap2!=icap)RawPedSigs[icap2][icap]=RawPedSigs[icap][icap2];
        }
      }

// first quick check if raw values make sense: if not, the channel is treated like absent
      for (int icap=0; icap<4; icap++) {
        if(RawPedVals[icap]<1. || RawPedSigs[icap][icap]<0.01) isinRaw[detid]=false;
        for (int icap2=icap; icap2<4; icap2++){
          if(fabs(RawPedSigs[icap][icap2]/sqrt(RawPedSigs[icap][icap]*RawPedSigs[icap2][icap2]))>1.) isinRaw[detid]=false;
        }
      }
    }

// check raw values against reference
    if(isinRaw[detid]) {
      for (int icap=0; icap<4; icap++) {
        int icap2=(icap+1)%4;
        float width=sqrt(RawPedSigs[icap][icap]);
        float erof1=width/sqrt((float)nstat[icap]);
        float erof2=sqrt(erof1*erof1+RawPedSigs[icap][icap]/(float)nstat[icap]);
        float erofwidth=width/sqrt(2.*nstat[icap]);
        float diffof1=RawPedVals[icap]-RefPedVals[icap];
        float diffof2=RawPedVals[icap]+RawPedVals[icap2]-RefPedVals[icap]-RefPedVals[icap2];
        float diffofw=width-sqrt(RefPedSigs[icap][icap]);

// validation in 2 TS for HB, HE, HO, in 1 TS for HF
        int nTS=2;
        if(detid.subdet()==HcalForward) nTS=1;
        if(nTS==1 && fabs(diffof1)>0.5+erof1) { 
          erflag+=1;
          PedValLog<<"HcalPedVal: drift in channel "<<detid<<" cap "<<icap<<": "<<RawPedVals[icap]<<" - "<<RefPedVals[icap]<<" = "<<diffof1<<std::endl;
        }
        if(nTS==2 && fabs(diffof2)>0.5+erof2) { 
          erflag+=1;
          PedValLog<<"HcalPedVal: drift in channel "<<detid<<" caps "<<icap<<"+"<<icap2<<": "<<RawPedVals[icap]<<"+"<<RawPedVals[icap2]<<" - "<<RefPedVals[icap]<<"+"<<RefPedVals[icap2]<<" = "<<diffof2<<std::endl;
        }
        if(fabs(diffofw)>0.15*width+erofwidth) {
          erflag+=1;
          PedValLog<<"HcalPedVal: width changed in channel "<<detid<<" cap "<<icap<<": "<<width<<" - "<<sqrt(RefPedSigs[icap][icap])<<" = "<<diffofw<<std::endl;
        }
      }
    }

// for disconnected/bad channels restore reference values
    else {
      PedValLog<<"HcalPedVal: no valid data from channel "<<detid<<std::endl;
      erflag+=100000;
      CastorPedestal item(detid,RefPedVals[0],RefPedVals[1],RefPedVals[2],RefPedVals[3]);
      fValPedestals->addValues(item);
      CastorPedestalWidth widthsp(detid);
      for (int icap=0; icap<4; icap++) {
        for (int icap2=icap; icap2<4; icap2++) widthsp.setSigma(icap2,icap,RefPedSigs[icap2][icap]);
      }
      fValPedestalWidths->addValues(widthsp);
    }

// end of channel loop
  }

  if(erflag==0) PedValLog<<"HcalPedVal: all pedestals checked OK"<<std::endl;

// now construct the remaining part of the validated objects
// if nothing changed outside tolerance, validated set = reference set
  if(erflag%100000 == 0) {
    for (int i=0; i<(int)RefChanns.size(); i++){
      detid=HcalDetId(RefChanns[i]);
      if (isinRaw[detid]) {
        CastorPedestalWidth widthsp(detid);
        for (int icap=0; icap<4; icap++) {
          RefPedVals[icap]=fRefPedestals->getValues(detid)->getValue(icap);
          for (int icap2=icap; icap2<4; icap2++) {
            RefPedSigs[icap][icap2]=fRefPedestalWidths->getValues(detid)->getSigma(icap,icap2);
            if(icap2!=icap)RefPedSigs[icap2][icap]=RefPedSigs[icap][icap2];
            widthsp.setSigma(icap2,icap,RefPedSigs[icap2][icap]);
          }
        }
        fValPedestalWidths->addValues(widthsp);
        CastorPedestal item(detid,RefPedVals[0],RefPedVals[1],RefPedVals[2],RefPedVals[3]);
        fValPedestals->addValues(item);
      }
    }
  }

// if anything changed, validated set = raw set + reference for missing/bad channels
  else {
    for (int i=0; i<(int)RawChanns.size(); i++){
      detid=HcalDetId(RawChanns[i]);
      if (isinRaw[detid]) {
        CastorPedestalWidth widthsp(detid);
        for (int icap=0; icap<4; icap++) {
          RawPedVals[icap]=fRawPedestals->getValues(detid)->getValue(icap);
          for (int icap2=icap; icap2<4; icap2++) {
            RawPedSigs[icap][icap2]=fRawPedestalWidths->getValues(detid)->getSigma(icap,icap2);
            if(icap2!=icap)RawPedSigs[icap2][icap]=RawPedSigs[icap][icap2];
            widthsp.setSigma(icap2,icap,RawPedSigs[icap2][icap]);
          }
        }
        fValPedestalWidths->addValues(widthsp);
        CastorPedestal item(detid,RawPedVals[0],RawPedVals[1],RawPedVals[2],RawPedVals[3]);
        fValPedestals->addValues(item);
      }
    }
  }
  return erflag;
}

int CastorPedestalAnalysis::done	(	const CastorPedestals *	fInputPedestals,
		const CastorPedestalWidths *	fInputWidths,
		CastorPedestals *	fOutputPedestals,
		CastorPedestalWidths *	fOutputWidths
	)

Definition at line 414 of file CastorPedestalAnalysis.cc.

References castorHists, CastorPedVal(), gather_cfg::cout, evt, fRawPedestals, fRawPedestalWidths, fRefPedestals, fRefPedestalWidths, fValPedestals, fValPedestalWidths, i, m_AllPedsOK, m_file, m_nevtsample, m_outputFileROOT, m_pedValflag, m_stat, SampleAnalysis(), and Trendings().

{
   int nstat[4];

// Pedestal objects
  // inputs...
  fRefPedestals = fInputPedestals;
  fRefPedestalWidths = fInputPedestalWidths;
  
  // outputs...
  if(m_pedValflag>0) {
    fValPedestals = fOutputPedestals;
    fValPedestalWidths = fOutputPedestalWidths;
    fRawPedestals = new CastorPedestals();
    fRawPedestalWidths = new CastorPedestalWidths();
  }
  else {
    fRawPedestals = fOutputPedestals;
    fRawPedestalWidths = fOutputPedestalWidths;
    fValPedestals = new CastorPedestals();
    fValPedestalWidths = new CastorPedestalWidths();
  }

// compute pedestal constants
  if(m_nevtsample<1) SampleAnalysis();
  if(m_nevtsample>0) {
    if(evt%m_nevtsample!=0) SampleAnalysis();
  }

// trending histos
  if(m_nevtsample>0){
    m_file->cd();
    m_file->cd("Castor");
    Trendings(castorHists.PEDTRENDS,castorHists.CHI2,castorHists.CAPID_AVERAGE,castorHists.CAPID_CHI2);
  }

  if (m_nevtsample<1) {

// pedestal validation: m_AllPedsOK=-1 means not validated,
//                                   0 everything OK,
//                                   N>0 : mod(N,100000) drifts + width changes
//                                         int(N/100000) missing channels
    m_AllPedsOK=-1;
    if(m_pedValflag>0) {
      for (int i=0; i<4; i++) nstat[i]=(int)m_stat[i];
      int NPedErrors=CastorPedVal(nstat,fRefPedestals,fRefPedestalWidths,
                            fRawPedestals,fRawPedestalWidths,
                            fValPedestals,fValPedestalWidths);
      m_AllPedsOK=NPedErrors;
    }
// setting m_AllPedsOK=-2 will inhibit writing pedestals out
//    if(m_pedValflag==1){
//      if(evt<100)m_AllPedsOK=-2;
//    }

  }

  // Write other histograms.

  // Castor
  m_file->cd();
  m_file->cd("Castor");
  castorHists.ALLPEDS->Write();
  castorHists.PEDRMS->Write();
  castorHists.PEDMEAN->Write();

  m_file->Close();
  cout << "Hcal/Castor histograms written to " << m_outputFileROOT.c_str() << endl;
  return (int)m_AllPedsOK;
}

void CastorPedestalAnalysis::GetPedConst	(	std::map< HcalDetId, std::map< int, PEDBUNCH > > &	toolT,
		TH1F *	PedMeans,
		TH1F *	PedWidths
	)		`[private]`

Referenced by SampleAnalysis().

void CastorPedestalAnalysis::per2CapsHists	(	int	flag,
		int	id,
		const HcalDetId	detid,
		const HcalQIESample &	qie1,
		const HcalQIESample &	qie2,
		std::map< HcalDetId, std::map< int, PEDBUNCH > > &	toolT,
		const CastorDbService &	cond
	)		`[private]`

Referenced by processEvent().

void CastorPedestalAnalysis::processEvent	(	const CastorDigiCollection &	castor,
		const CastorDbService &	cond
	)

Definition at line 90 of file CastorPedestalAnalysis.cc.

References AllChanHists(), edm::SortedCollection< T, SORT >::begin(), castorHists, edm::SortedCollection< T, SORT >::end(), evt, evt_curr, CastorDbService::getCastorCoder(), CastorDbService::getCastorShape(), i, CastorDataFrame::id(), j, m_coder, m_endTS, m_nevtsample, m_shape, m_startTS, per2CapsHists(), sample, CastorDataFrame::sample(), SampleAnalysis(), edm::SortedCollection< T, SORT >::size(), and CastorDataFrame::size().

{
  evt++;
  sample=1;
  evt_curr=evt;
  if(m_nevtsample>0) {
    sample = (evt-1)/m_nevtsample +1;
    evt_curr = evt%m_nevtsample;
    if(evt_curr==0)evt_curr=m_nevtsample;
  }

  m_shape = cond.getCastorShape();
  // HF
  try{
    if(!castor.size()) throw (int)castor.size();
    for (CastorDigiCollection::const_iterator j=castor.begin(); j!=castor.end(); j++){
      const CastorDataFrame digi = (const CastorDataFrame)(*j);
      m_coder = cond.getCastorCoder(digi.id());
      for (int i=m_startTS; i<digi.size() && i<=m_endTS; i++) {
        for(int flag=0; flag<4; flag++){
          if(i+flag<digi.size() && i+flag<=m_endTS){
            per2CapsHists(flag,2,digi.id(),digi.sample(i),digi.sample(i+flag),castorHists.PEDTRENDS,cond);
          }
        }
      }
      if(m_startTS==0 && m_endTS>4){
        AllChanHists(digi.id(),digi.sample(0),digi.sample(1),digi.sample(2),digi.sample(3),digi.sample(4),digi.sample(5),castorHists.PEDTRENDS);
      }
    }
  } 
  catch (int i ) {
//    m_logFile << "Event with " << i<<" Castor Digis passed." << std::endl;
  } 
  // Call the function every m_nevtsample events
  if(m_nevtsample>0) {
    if(evt%m_nevtsample==0) SampleAnalysis();
  }
}

void CastorPedestalAnalysis::SampleAnalysis ( )

Definition at line 251 of file CastorPedestalAnalysis.cc.

References castorHists, GetPedConst(), m_file, and sample.

Referenced by done(), and processEvent().

                                           {
  // it is called every m_nevtsample events (a sample) and the end of run
  char PedSampleNum[20];

// Compute pedestal constants for each HBHE, HO, HF
  sprintf(PedSampleNum,"Castor_Sample%d",sample);
  m_file->cd();
  m_file->mkdir(PedSampleNum);
  m_file->cd(PedSampleNum);
  GetPedConst(castorHists.PEDTRENDS,castorHists.PEDMEAN,castorHists.PEDRMS);
}

void CastorPedestalAnalysis::setup ( const std::string & m_outputFileROOT )

Definition at line 82 of file CastorPedestalAnalysis.cc.

References m_file.

                                                                    {
  // open the histogram file, create directories within
  m_file=new TFile(m_outputFileROOT.c_str(),"RECREATE");
  m_file->mkdir("Castor");
  m_file->cd();
}

void CastorPedestalAnalysis::Trendings	(	std::map< HcalDetId, std::map< int, PEDBUNCH > > &	toolT,
		TH1F *	Chi2,
		TH1F *	CapidAverage,
		TH1F *	CapidChi2
	)		`[private]`