LArCaliWaves2Ntuple.cxx File Reference

#include "LArCalibTools/LArCaliWaves2Ntuple.h"
#include "CaloIdentifier/CaloGain.h"

Include dependency graph for LArCaliWaves2Ntuple.cxx:

Go to the source code of this file.

Functions
StatusCode LArCaliWaves2Ntuple::stop	ATLAS_NOT_THREAD_SAFE ()
	Install fatal handler with default options.

Function Documentation

ATLAS_NOT_THREAD_SAFE()

StatusCode LArCaliWaves2Ntuple::stop ATLAS_NOT_THREAD_SAFE ( void )

inline

Install fatal handler with default options.

This is meant to be easy to call from python via ctypes.

Install fatal handler with default options.

getLorentzAngle() Read LorentzAngle from HIST and write out into local DB

getBSErrors() Read BSErrors from Monitoring HIST and write out into local DB

getEfficiency() Read Efficiency from Monitoring HIST and write out into local DB

getRawOccupancy() Read RawOccupancy from Monitoring HIST and write out into local DB

getNoiseOccupancy() Read NoiseOccupancy from HIST and write out into local DB

getNoisyStrip() Find noisy strips from hitmaps and write out into xml/db formats

beginning of the loop of channels

bad bit newly found

known bad bit

for low noisy cells

for high noisy cells

0.01 is used to scale "PER" to the same order of magnitude to "SIG"

smaller deviation: distorted

checking TmaxAmp, Not mixed with MaxAmp and Width

channel information output

Only dead or distorted, or short known BCs are considered below.

index of bc

Definition at line 48 of file LArCaliWaves2Ntuple.cxx.

{ 
  
  // Check DACSatur jobOption consistency, in case setup default values
  if ( m_dacSaturSkip && m_dacSaturLayer0.size()<3 ) {
     ATH_MSG_WARNING( "DACSaturPS     jobOption has wrong size. Will use default." ) ;
     m_dacSaturLayer0.resize(3);
     m_dacSaturLayer0[0] = 15000 ; 
     m_dacSaturLayer0[1] = 50000 ;
     m_dacSaturLayer0[2] = 65000 ;
  }
  if ( m_dacSaturSkip && m_dacSaturLayer1.size()<3 ) {
     ATH_MSG_WARNING( "DACSaturStrips jobOption has wrong size. Will use default." ) ;
     m_dacSaturLayer1.resize(3);
     m_dacSaturLayer1[0] = 800 ; 
     m_dacSaturLayer1[1] = 8000 ;
     m_dacSaturLayer1[2] = 65000 ;
  }
  if ( m_dacSaturSkip && m_dacSaturLayer2.size()<3 ) {
     ATH_MSG_WARNING( "DACSaturMiddle jobOption has wrong size. Will use default." ) ;
     m_dacSaturLayer2.resize(3);
     m_dacSaturLayer2[0] = 1000 ; 
     m_dacSaturLayer2[1] = 10000 ;
     m_dacSaturLayer2[2] = 65000 ;
  }
  if ( m_dacSaturSkip && m_dacSaturLayer3.size()<3 ) {
     ATH_MSG_WARNING( "DACSaturBack   jobOption has wrong size. Will use default." ) ;
     m_dacSaturLayer3.resize(3);
     m_dacSaturLayer3[0] = 800 ; 
     m_dacSaturLayer3[1] = 8000 ;
     m_dacSaturLayer3[2] = 65000 ;
  }
 
  StatusCode sc;
  sc=m_nt->addItem("DAC",m_dac,0,600000);
  if (sc!=StatusCode::SUCCESS) {
    ATH_MSG_ERROR( "addItem 'DAC' failed" );
    return StatusCode::FAILURE;
  }
 
  sc=m_nt->addItem("gain",m_gain,0,3);
  if (sc!=StatusCode::SUCCESS) {
    ATH_MSG_ERROR( "addItem 'gain' failed" );
    return StatusCode::FAILURE;
  }
 
  if (m_addCalib) {
    sc=m_nt->addItem("nPulsedCalibLines",m_nPulsedCalibLines,0,4);
    if (sc!=StatusCode::SUCCESS) {
      ATH_MSG_ERROR( "addItem 'nPulsedCalibLines' failed" );
      return StatusCode::FAILURE;
    }
    
    sc=m_nt->addItem("pulsedCalibLines",4,m_pulsedCalibLines);
    if (sc!=StatusCode::SUCCESS) {
      ATH_MSG_ERROR( "addItem 'pulsedCalibLines' failed" );
      return StatusCode::FAILURE;
    }
  }
 
  if (m_saveJitter) {
    sc=m_nt->addItem("Jitter",m_jitter,0.,1.);
    if (sc!=StatusCode::SUCCESS) {
      ATH_MSG_ERROR( "addItem 'Jitter' failed" );
      return StatusCode::FAILURE;
    } 
  }
  
  if (m_addCorrUndo) {
    sc=m_nt->addItem("corrUndo",m_corrUndo,0,1);
    if (sc!=StatusCode::SUCCESS) {
      ATH_MSG_ERROR( "addItem 'corrUndo' failed" );
      return StatusCode::FAILURE;
    }
  }
 
  
  const LArCalibLineMapping *clCont=nullptr;
  if(m_isSC) {
    ATH_MSG_DEBUG( "LArCaliWaves2Ntuple: using SC calib map" );
    SG::ReadCondHandle<LArCalibLineMapping> clHdl{m_calibMapSCKey};
    clCont=*clHdl;
  } else {
    SG::ReadCondHandle<LArCalibLineMapping> clHdl{m_calibMapKey};
    clCont=*clHdl;
  }
  
  if(!clCont) {
     ATH_MSG_WARNING( "Do not have calib line mapping !!!" );
     return StatusCode::FAILURE;
  }
 
  for ( unsigned k=0 ; k<m_keylist.size() ; k++ ) {
    const std::string& key = m_keylist[k] ;
 
 
    ATH_MSG_INFO( "Processing WaveContainer from StoreGate! key=" << m_keylist[k] ); 
    const LArCaliWaveContainer* caliWaveContainer = nullptr;
    StatusCode sc = m_detStore->retrieve(caliWaveContainer,key);      
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Cannot read LArCaliWaveContainer from StoreGate! key=" << key );
      return StatusCode::FAILURE;
    } else 
      ATH_MSG_INFO( "Read LArCaliWaveContainer from StoreGate! key= "  << key );
    LArCaliWaveContainer* caliWaveContainer_nc=nullptr;
    if (m_applyCorr) {
      if (!caliWaveContainer->correctionsApplied()) {
    caliWaveContainer_nc=const_cast<LArCaliWaveContainer*>(caliWaveContainer);
    sc=caliWaveContainer_nc->applyCorrections();
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Failed to apply corrections to LArCaliWaveContainer!" );
    }
    else
      ATH_MSG_INFO( "Applied corrections to LArCaliWaveContainer" );
      }
      else {
    ATH_MSG_WARNING( "Corrections already applied. Can't apply twice!" );
      }
    }// end if applyCorr
 
    
    for (unsigned igain=CaloGain::LARHIGHGAIN;igain<CaloGain::LARNGAIN ;++igain){
      for (const HWIdentifier chid: m_onlineId->channel_range()) {
    m_gain=(long)igain;
    const LArCaliWaveVec& cwv = caliWaveContainer->get(chid,igain);
    if (cwv.empty()) continue;
    
    LArCaliWaveVec::const_iterator cwv_it=cwv.begin();
    LArCaliWaveVec::const_iterator cwv_it_e=cwv.end();
    for (;cwv_it!=cwv_it_e;++cwv_it) {
      const LArCaliWave& wave=*cwv_it;
      if (wave.isEmpty()) continue;
      if (m_addCorrUndo) m_corrUndo=0;
      bool skip=writeEntry(chid,igain,wave,clCont);
      if (skip) continue;
      sc=ntupleSvc()->writeRecord(m_nt);
      if (sc!=StatusCode::SUCCESS) {
        ATH_MSG_ERROR( "writeRecord failed" );
        return sc;
      }
    }//End loop over DAC 
      }//end loop over identifiers
    }//end loop over gains
 
 
    if (m_addCorrUndo) {
      for (unsigned igain=CaloGain::LARHIGHGAIN;igain<CaloGain::LARNGAIN ;++igain) {
    LArCaliWaveContainer::ConstCorrectionIt itUndo=caliWaveContainer->undoCorrBegin(igain);
    LArCaliWaveContainer::ConstCorrectionIt itUndo_e=caliWaveContainer->undoCorrEnd(igain);
    for(;itUndo!=itUndo_e;itUndo++) {
      const HWIdentifier chid(itUndo->first);
      const LArCaliWaveVec& cwv = itUndo->second;
      LArCaliWaveVec::const_iterator cwv_it=cwv.begin();
      LArCaliWaveVec::const_iterator cwv_it_e=cwv.end();
      for (;cwv_it!=cwv_it_e;++cwv_it) {
        const LArCaliWave& wave=*cwv_it;
        m_gain  = (long)igain;
        m_corrUndo = 1;
        bool skip=writeEntry(chid,igain,wave,clCont);
        if (skip) continue;
        sc=ntupleSvc()->writeRecord(m_nt);
        if (sc!=StatusCode::SUCCESS) {
          ATH_MSG_ERROR( "writeRecord failed" );
          return sc;
        }
      }//end loop over DAC
    }//end loop over corrections
      }//end loop over gain
    }//end if addUndoCorr
    if (caliWaveContainer_nc) {
      ATH_CHECK(caliWaveContainer_nc->undoCorrections());
      ATH_MSG_INFO("Reverted corrections of CaliWave container");
    }
  }
  ATH_MSG_INFO( "LArWave2Ntuple has finished." );
  return StatusCode::SUCCESS;
} // end finalize-method.