| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

In This Package:

PmtCalibLeadingEdge Class Reference

#include <PmtCalibLeadingEdge.h>

Inheritance diagram for PmtCalibLeadingEdge:

[legend]
Collaboration diagram for PmtCalibLeadingEdge:
[legend]
List of all members.

Public Types

 SUCCESS
 NO_INTERFACE
 VERSMISMATCH
 LAST_ERROR
 SUCCESS
 NO_INTERFACE
 VERSMISMATCH
 LAST_ERROR
enum  Status

Public Member Functions

 PmtCalibLeadingEdge (const std::string &type, const std::string &name, const IInterface *parent)
virtual ~PmtCalibLeadingEdge ()
virtual StatusCode initialize ()
virtual StatusCode finalize ()
virtual StatusCode process (const DayaBay::ReadoutHeader &readout)
 process(const DayaBay::ReadoutPmtCrate&) process a single readout, extracting the information needed for calibration
virtual StatusCode calibrate ()
 calibrate() is called after processing many readouts.
INTupleSvc * ntupleSvc () const
INTupleSvc * evtColSvc () const
IDataProviderSvc * detSvc () const
IDataProviderSvc * evtSvc () const
IIncidentSvc * incSvc () const
IChronoStatSvc * chronoSvc () const
IHistogramSvc * histoSvc () const
IAlgContextSvc * contextSvc () const
DataObject * put (IDataProviderSvc *svc, DataObject *object, const std::string &address, const bool useRootInTES=true) const
DataObject * put (DataObject *object, const std::string &address, const bool useRootInTES=true) const
Gaudi::Utils::GetData< TYPE
>::return_type 		get (IDataProviderSvc *svc, const std::string &location, const bool useRootInTES=true) const
Gaudi::Utils::GetData< TYPE
>::return_type 		get (const std::string &location, const bool useRootInTES=true) const
TYPE * getDet (IDataProviderSvc *svc, const std::string &location) const
TYPE * getDet (const std::string &location) const
bool exist (IDataProviderSvc *svc, const std::string &location, const bool useRootInTES=true) const
bool exist (const std::string &location, const bool useRootInTES=true) const
bool existDet (IDataProviderSvc *svc, const std::string &location) const
bool existDet (const std::string &location) const
TYPE * getOrCreate (IDataProviderSvc *svc, const std::string &location, const bool useRootInTES=true) const
TYPE * getOrCreate (const std::string &location, const bool useRootInTES=true) const
TOOL * tool (const std::string &type, const std::string &name, const IInterface *parent=0, bool create=true) const
TOOL * tool (const std::string &type, const IInterface *parent=0, bool create=true) const
SERVICE * svc (const std::string &name, const bool create=true) const
IUpdateManagerSvc * updMgrSvc () const
IDataProviderSvc * fastContainersSvc () const
StatusCode Error (const std::string &msg, const StatusCode st=StatusCode::FAILURE, const size_t mx=10) const
StatusCode Warning (const std::string &msg, const StatusCode st=StatusCode::FAILURE, const size_t mx=10) const
StatusCode Print (const std::string &msg, const StatusCode st=StatusCode::SUCCESS, const MSG::Level lev=MSG::INFO) const
StatusCode Assert (const bool ok, const std::string &message="", const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
StatusCode Assert (const bool ok, const char *message, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
StatusCode Exception (const std::string &msg, const GaudiException &exc, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
StatusCode Exception (const std::string &msg, const std::exception &exc, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
StatusCode Exception (const std::string &msg="no message", const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
MsgStream & msgStream (const MSG::Level level) const
MsgStream & always () const
MsgStream & fatal () const
MsgStream & err () const
MsgStream & error () const
MsgStream & warning () const
MsgStream & info () const
MsgStream & debug () const
MsgStream & verbose () const
MsgStream & msg () const
const Statistics & counters () const
StatEntity & counter (const std::string &tag) const
MSG::Level msgLevel () const
bool msgLevel (const MSG::Level level) const
void resetMsgStream () const
bool typePrint () const
bool propsPrint () const
bool statPrint () const
bool errorsPrint () const
long printStat (const MSG::Level level=MSG::ALWAYS) const
long printErrors (const MSG::Level level=MSG::ALWAYS) const
long printProps (const MSG::Level level=MSG::ALWAYS) const
void registerCondition (const std::string &condition, StatusCode(CallerClass::*mf)()=NULL)
void registerCondition (const std::string &condition, CondType *&condPtrDest, StatusCode(CallerClass::*mf)()=NULL)
void registerCondition (char *condition, StatusCode(CallerClass::*mf)()=NULL)
void registerCondition (TargetClass *condition, StatusCode(CallerClass::*mf)()=NULL)
StatusCode runUpdate ()
TransientFastContainer< T > * getFastContainer (const std::string &location, typename TransientFastContainer< T >::size_type initial=0)
StatusCode release (const IInterface *interface) const
virtual unsigned long release ()
const std::string & context () const
const std::string & rootInTES () const
double globalTimeOffset () const
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvUnknown)
virtual unsigned long addRef ()
virtual const std::string & name () const
virtual const std::string & type () const
virtual const IInterface * parent () const
virtual StatusCode configure ()
virtual StatusCode start ()
virtual StatusCode stop ()
virtual StatusCode terminate ()
virtual StatusCode reinitialize ()
virtual StatusCode restart ()
virtual Gaudi::StateMachine::State FSMState () const
virtual Gaudi::StateMachine::State targetFSMState () const
virtual StatusCode sysInitialize ()
virtual StatusCode sysStart ()
virtual StatusCode sysStop ()
virtual StatusCode sysFinalize ()
virtual StatusCode sysReinitialize ()
virtual StatusCode sysRestart ()
virtual StatusCode setProperty (const Property &p)
virtual StatusCode setProperty (const std::string &s)
virtual StatusCode setProperty (const std::string &n, const std::string &v)
StatusCode setProperty (const std::string &name, const TYPE &value)
virtual StatusCode getProperty (Property *p) const
virtual const Property & getProperty (const std::string &name) const
virtual StatusCode getProperty (const std::string &n, std::string &v) const
virtual const std::vector<
Property * > & 		getProperties () const
PropertyMgr * getPropertyMgr ()
ISvcLocator * serviceLocator () const
ISvcLocator * svcLoc () const
IMessageSvc * msgSvc () const
IToolSvc * toolSvc () const
StatusCode setProperties ()
StatusCode service (const std::string &name, T *&svc, bool createIf=true) const
StatusCode service (const std::string &type, const std::string &name, T *&svc) const
void declInterface (const InterfaceID &, void *)
Property * declareProperty (const std::string &name, T &property, const std::string &doc="none") const
Property * declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="") const
IAuditorSvc * auditorSvc () const
IMonitorSvc * monitorSvc () const
void declareInfo (const std::string &name, const T &var, const std::string &desc) const
void declareInfo (const std::string &name, const std::string &format, const void *var, int size, const std::string &desc) const
virtual const std::string & type () const =0
virtual const IInterface * parent () const =0
virtual StatusCode configure ()=0
virtual StatusCode start ()=0
virtual StatusCode stop ()=0
virtual StatusCode terminate ()=0
virtual StatusCode reinitialize ()=0
virtual StatusCode restart ()=0
virtual Gaudi::StateMachine::State FSMState () const =0
virtual StatusCode sysInitialize ()=0
virtual StatusCode sysStart ()=0
virtual StatusCode sysStop ()=0
virtual StatusCode sysFinalize ()=0
virtual StatusCode sysReinitialize ()=0
virtual StatusCode sysRestart ()=0
virtual unsigned long refCount () const =0
virtual const std::string & name () const =0
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvInterface)=0
virtual unsigned long addRef ()=0
virtual unsigned long release ()=0

Static Public Member Functions

static const InterfaceID & interfaceID ()
static const InterfaceID & interfaceID ()
static const InterfaceID & interfaceID ()
static const InterfaceID & interfaceID ()
 Retrieve interface ID.

Public Attributes

 SUCCESS
 NO_INTERFACE
 VERSMISMATCH
 LAST_ERROR

Protected Types

typedef std::map< std::string,
StatEntity > 		Statistics
typedef std::map< std::string,
unsigned int > 		Counter
typedef std::vector< IAlgTool * > AlgTools
typedef std::pair< IInterface *,
std::string > 		ServiceEntry
typedef std::vector< ServiceEntry > Services

Protected Member Functions

StatusCode releaseTool (const IAlgTool *tool) const
StatusCode releaseSvc (const IInterface *svc) const
int outputLevel () const
virtual unsigned long refCount () const
IntegerProperty & outputLevelProperty ()
void initOutputLevel (Property &prop)

Static Protected Attributes

static const bool IgnoreRootInTES
static const bool UseRootInTES

Private Member Functions

bool hasStats (const DayaBay::Detector &detector)
 Check if the statistics for this detector have been initialized.
StatusCode prepareStats (const Context &context)
 Get the current statistics for a detector, or create if needed.
std::string getPath (const DayaBay::Detector &detector)
std::string getPath (const DayaBay::Detector &detector, int ring)
std::string getPath (const DayaBay::FeeChannelId &channelId)
bool GoodTdc (int Tdc)

Private Attributes

std::string m_cableSvcName
std::string m_calibSvcName
std::string m_floatFeePedesSvcName
std::string m_filepath
ICableSvc * m_cableSvc
ICalibDataSvc * m_calibSvc
IStatisticsSvc * m_statsSvc
IFloatingFeePedestalSvc * m_floatFeePedesSvc
bool m_useFloatFeePedes
std::vector< DayaBay::Detector > m_processedDetectors
ofstream m_textFile
string m_textFileName

Detailed Description

Definition at line 73 of file PmtCalibLeadingEdge.h.

Constructor & Destructor Documentation

PmtCalibLeadingEdge::PmtCalibLeadingEdge ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 15 of file PmtCalibLeadingEdge.cc.

00018   : GaudiTool(type,name,parent)
00019   , m_cableSvc(0)
00020   , m_statsSvc(0)
00021 {
00022   
00023   declareInterface< IPmtCalibParamTool >(this) ;   
00024   declareProperty("CableSvcName",m_cableSvcName="StaticCableSvc",
00025                   "Name of service to map between detector, hardware, and electronic IDs");
00026   declareProperty("CalibSvcName",m_calibSvcName="StaticCalibDataSvc",
00027                   "Name of service to access FEE channel baselines");
00028   declareProperty("FloatingFeePedestalSvcName",m_floatFeePedesSvcName="FloatingFeePedestalSvc",
00029                   "Name of service to access floating FEE channel baselines");
00030   declareProperty("UseFloatFeePedes",m_useFloatFeePedes=false,
00031                   "Use FloatFeePedes or not? In case of false, it will use CalibSvc.");
00032   declareProperty("FilePath",m_filepath="/file0/pmtCalibLeadingEdge",
00033                   "File path of registered histograms.");
00034 
00035   declareProperty("TextFile", m_textFileName="Sum.txt", "Summary of fitting result in text file");
00036 
00037 }

PmtCalibLeadingEdge::~PmtCalibLeadingEdge (  )  [virtual]

Definition at line 39 of file PmtCalibLeadingEdge.cc.

00039 {}

Member Function Documentation

StatusCode PmtCalibLeadingEdge::initialize (  )  [virtual]

Reimplemented from GaudiTool.

Definition at line 41 of file PmtCalibLeadingEdge.cc.

00042 {
00043   info() << "initialize()" << endreq;
00044   StatusCode sc = this->GaudiTool::initialize();
00045   if( sc != StatusCode::SUCCESS ) return sc;
00046 
00047   // Get Cable Service
00048   m_cableSvc = svc<ICableSvc>(m_cableSvcName,true);
00049   if(!m_cableSvc){
00050     error() << "Failed to access cable svc: " << m_cableSvcName << endreq;
00051     return StatusCode::FAILURE;
00052   }
00053 
00054   // Get Calibration Service
00055   m_calibSvc = svc<ICalibDataSvc>(m_calibSvcName,true);
00056   if(!m_calibSvc){
00057     error() << "Failed to access calibration svc: " << m_calibSvcName << endreq;
00058     return StatusCode::FAILURE;
00059   }
00060 
00061   if(m_useFloatFeePedes){
00062     // Get floating fee pedestal service
00063     m_floatFeePedesSvc = svc<IFloatingFeePedestalSvc>(m_floatFeePedesSvcName,true);
00064     if(!m_floatFeePedesSvc){
00065       error() << "Failed to access FloatingFeePedestalSvc: " << m_floatFeePedesSvcName << endreq;
00066       return StatusCode::FAILURE;
00067     }
00068   }
00069 
00070   // Get the histogram service
00071   m_statsSvc = svc<IStatisticsSvc>("StatisticsSvc",true);
00072   if(!m_statsSvc) {
00073     error() << " No StatisticsSvc available." << endreq;
00074     return StatusCode::FAILURE;
00075   }
00076 
00077   // Initialize data from input file.
00078   // Processed detectors are identified by directory name.
00079   std::vector<std::string> detDirs = m_statsSvc->getSubFolders(m_filepath);
00080   std::vector<std::string>::iterator dirIter, dirEnd = detDirs.end();
00081   for(dirIter=detDirs.begin(); dirIter != dirEnd; dirIter++){
00082     info() << "Processing input directory: " << m_filepath << "/" 
00083            << *dirIter << endreq;
00084     DayaBay::Detector detector( 
00085                  DayaBay::Detector::siteDetPackedFromString(*dirIter) );
00086     if( detector.site() == Site::kUnknown 
00087         || detector.detectorId() == DetectorId::kUnknown ){
00088       warning() << "Input directory: " << m_filepath << "/" 
00089                 << *dirIter << " not processed." << endreq;
00090     }
00091     m_processedDetectors.push_back(detector);
00092   }
00093 
00094   m_textFile.open( m_textFileName.c_str(), ios_base::out );
00095 
00096   m_textFile
00097     <<"run/I:board/I:channel/I:preAdc/D:preAdcSigma/D:rawAdc/D:rawAdcSigma/D:expAdc/D:expAdcSigma/D:quasiAdc/D:quasiAdcSigma/D"<<endl;
00098 
00099   return StatusCode::SUCCESS;
00100 }

StatusCode PmtCalibLeadingEdge::finalize (  )  [virtual]

Reimplemented from GaudiTool.

Definition at line 102 of file PmtCalibLeadingEdge.cc.

00103 {
00104   StatusCode sc = this->GaudiTool::finalize();
00105   if( sc != StatusCode::SUCCESS ) return sc;
00106 
00107   m_textFile.close();
00108 
00109   return StatusCode::SUCCESS;
00110 }

StatusCode PmtCalibLeadingEdge::process ( const DayaBay::ReadoutHeader &  readout  )  [virtual]

process(const DayaBay::ReadoutPmtCrate&) process a single readout, extracting the information needed for calibration

Restrict to fine range gain measurement

Implements IPmtCalibParamTool.

Definition at line 114 of file PmtCalibLeadingEdge.cc.

00114                                                                                 {
00115 
00116   const DayaBay::DaqCrate* daqCrate = readoutHeader.daqCrate();
00117   if(!daqCrate){
00118     error() << "Failed to get DAQ crate from header" << endreq;
00119     return StatusCode::FAILURE;
00120   }
00121 
00122   const DayaBay::Detector& detector = daqCrate->detector();
00123 
00124   // Convert to PMT crate readout
00125   const DayaBay::DaqPmtCrate* pmtCrate
00126       = daqCrate->asPmtCrate();
00127   if(!pmtCrate){
00128     // Not an AD, continue
00129     debug() << "process(): Do not process detector: " << detector.detName() 
00130             << endreq;
00131     return StatusCode::SUCCESS;
00132   }
00133 
00134   Context context = readoutHeader.context();
00135   if( !hasStats(detector) ){
00136     // New detector; initialize all the detector statistics
00137     StatusCode sc = prepareStats(context);
00138     if( sc != StatusCode::SUCCESS ) return sc;
00139   }
00140   ServiceMode svcMode(context, 0);
00141 
00142   // Retrieve the parameters and histograms
00143   TObject* nReadoutsObj = 
00144     m_statsSvc->get(this->getPath(detector) + "/nReadouts");
00145   TParameter<int>* nReadoutsPar= dynamic_cast<TParameter<int>*>(nReadoutsObj);
00146   if(!nReadoutsPar) return StatusCode::FAILURE;
00147   TH1F* adcSumH = m_statsSvc->getTH1F( this->getPath(detector) + "/adcSum");
00148   if(!adcSumH) return StatusCode::FAILURE;
00149   TH1F* tdcMeanH = m_statsSvc->getTH1F( this->getPath(detector)+"/tdcMean");
00150   if(!tdcMeanH) return StatusCode::FAILURE;
00151   TH1F* NChannelH = m_statsSvc->getTH1F( this->getPath(detector) + "/NChannel");
00152   if(!NChannelH) return StatusCode::FAILURE;
00153   TH2F* occupancyH = m_statsSvc->getTH2F(this->getPath(detector) + "/occupancy");
00154   if(!occupancyH) return StatusCode::FAILURE;
00155 
00156   // Add the current readout to the calibration statistics
00157   std::vector<int> readoutTdc;
00158   double adcSum = 0;
00159   // Loop over channels
00160   int NChannel = 0;
00161 
00162   const DayaBay::DaqPmtCrate::PmtChannelPtrList& channels
00163     = pmtCrate->channelReadouts();
00164     
00165   DayaBay::DaqPmtCrate::PmtChannelPtrList::const_iterator channelIter, 
00166     channelEnd = channels.end();
00167   for(channelIter = channels.begin(); channelIter!=channelEnd; channelIter++) { 
00168     const DayaBay::DaqPmtChannel& channel = *(*channelIter);
00169     const DayaBay::FeeChannelId& chanId = channel.channelId();
00170     
00171     //const DayaBay::FeeCalibData* feeCalib = m_calibSvc->feeCalibData(chanId,svcMode);
00172 
00173     // Get Parameters and Histograms
00174     TObject* nHitsObj = m_statsSvc->get(this->getPath(chanId) + "/nHits");
00175     TParameter<int>* nHitsPar = dynamic_cast<TParameter<int>*>(nHitsObj);
00176     if(!nHitsPar) return StatusCode::FAILURE;
00177     TH1F* tdcRawH = m_statsSvc->getTH1F( this->getPath(chanId) + "/tdcRaw");
00178     if(!tdcRawH) return StatusCode::FAILURE;
00179     TH1F* adcRawH = m_statsSvc->getTH1F( this->getPath(chanId) + "/adcRaw");
00180     if(!adcRawH) return StatusCode::FAILURE;
00181     TH1F* preAdcH = m_statsSvc->getTH1F( this->getPath(chanId) + "/preAdc");
00182     if(!preAdcH) return StatusCode::FAILURE;
00183     TH1F* adcH = m_statsSvc->getTH1F( this->getPath(chanId) + "/adc");    
00184     if(!adcH) return StatusCode::FAILURE;
00185     TH1F* quasiAdcH = m_statsSvc->getTH1F( this->getPath(chanId) + "/quasiAdc");
00186     if(!quasiAdcH) return StatusCode::FAILURE;
00187     TH1F* adcByClockH = m_statsSvc->getTH1F( this->getPath(chanId) 
00188                                              + "/adcByClock");
00189     if(!adcByClockH) return StatusCode::FAILURE;
00190     
00191     // Loop over each hit
00192     bool FindFirstHit = false;
00193     for(unsigned int i=0; i<channel.hitCount(); i++) {
00194       int adcClock = channel.peakCycle(i);
00195       int adc = channel.adc(i);
00196       float preAdc = channel.preAdcAvg(i);
00197       int tdc = channel.tdc(i);
00198 
00199       // Only hit with good timing can join the fit and only the first one.
00200       if( FindFirstHit ) break;
00201       if( !GoodTdc(tdc) ) continue;
00202       FindFirstHit = true;
00203 
00204       // Loop over tdc values
00205       readoutTdc.push_back(tdc);
00206       tdcRawH->Fill(tdc);
00207     
00208       // Loop over adc values
00209       double adcBaseline;
00210       if( m_useFloatFeePedes ) {
00211         if(channel.isHighGainAdc(i)){
00212           adcBaseline = m_floatFeePedesSvc->pedestal( chanId, DayaBay::FeeGain::kHigh);
00213         }else{
00214           adcBaseline = m_floatFeePedesSvc->pedestal( chanId, DayaBay::FeeGain::kLow);
00215         }
00216         // In case floatFeePedesSvc didn't get enough statistics yet, use preAdc instead.
00217         if( adcBaseline<0 ) adcBaseline = channel.preAdcAvg(i);
00218       } else {
00219         // adcBaseline = feeCalib->m_adcBaselineLow;  // The pedestal run result is not good enough
00220         adcBaseline = channel.preAdcAvg(i);  // Use preAdc is much better
00221       }
00222 
00224       if( adc>0 && channel.isHighGainAdc(i) ) {
00225         adcRawH->Fill(adc);
00226         adcH->Fill(adc-adcBaseline);
00227         quasiAdcH->Fill(adc-preAdc);
00228         adcByClockH->Fill(adcClock,adc-adcBaseline);
00229         preAdcH->Fill(preAdc);
00230       }
00231       adcSum += adc-adcBaseline;
00232     }
00233     // Increment number of hits on this channel
00234     if( FindFirstHit ) {
00235       nHitsPar->SetVal( nHitsPar->GetVal() + 1 );
00236      }
00237   }
00238   NChannel = readoutTdc.size();
00239   if( NChannel<=0 ) {
00240     info()<<" Too few hits for this event. Skipped. "<<endreq;
00241     return StatusCode::SUCCESS;
00242   }
00243 
00244   if(readoutTdc.size() > 0){
00245     // Find the mean TDC
00246     double meanTdc = accumulate(readoutTdc.begin(), readoutTdc.end(),0);
00247     meanTdc = meanTdc/NChannel;
00248 
00249     for(channelIter = channels.begin(); channelIter!=channelEnd; channelIter++) { 
00250       const DayaBay::DaqPmtChannel& pmtChan = *(*channelIter);
00251       const DayaBay::FeeChannelId& chanId = pmtChan.channelId();
00252       TH1F* tdcByMeanH = 
00253         m_statsSvc->getTH1F( this->getPath(chanId) + "/tdcByMean");
00254       if(!tdcByMeanH) return StatusCode::FAILURE;
00255       // Loop over tdc values
00256       bool FirstHit = false;
00257       for(unsigned int i=0; i<pmtChan.hitCount(); i++) {
00258         int tdc = pmtChan.tdc(i);
00259         // Only hit with good timing can join the fit and only the first one.
00260         if( FirstHit ) break;
00261         if( !GoodTdc(tdc) ) continue;
00262         FirstHit = true;
00263         tdcByMeanH->Fill(tdc-meanTdc);
00264       }
00265     }
00266     tdcMeanH->Fill(meanTdc);
00267   }
00268 
00269   NChannelH->Fill(NChannel);
00270   adcSumH->Fill(adcSum);
00271   // Increment number of readouts from this detector
00272   nReadoutsPar->SetVal( nReadoutsPar->GetVal() + 1 );
00273   return StatusCode::SUCCESS;  
00274 }

StatusCode PmtCalibLeadingEdge::calibrate (  )  [virtual]

calibrate() is called after processing many readouts.

This method is responsible for calculating the calibration parameters.

Adc

Implements IPmtCalibParamTool.

Definition at line 276 of file PmtCalibLeadingEdge.cc.

00276                                          {
00277   // Loop over detectors in summary data, and calculate parameters
00278 
00279   std::vector<DayaBay::Detector>::iterator detIter, 
00280     detEnd = m_processedDetectors.end();
00281 
00282   for(detIter = m_processedDetectors.begin(); detIter != detEnd; detIter++){
00283     DayaBay::Detector detector = *detIter;
00284 
00285     if(!detector.isAD()) continue;//for now this code can only tolerate ADs (jpochoa)    
00286 
00287     // Retrieve the data description and histograms
00288     TObject* nReadoutsObj = 
00289       m_statsSvc->get(this->getPath(detector) + "/nReadouts");
00290     TParameter<int>* nReadoutsPar= dynamic_cast<TParameter<int>*>(nReadoutsObj);
00291     if(!nReadoutsPar) return StatusCode::FAILURE;
00292 
00293     TH1F* meanOccupancyH = m_statsSvc->getTH1F( this->getPath(detector)
00294                                                 +"/meanOccupancy");
00295     if(!meanOccupancyH) return StatusCode::FAILURE;
00296 
00297     TH1F* meanTdcOffsetH = m_statsSvc->getTH1F( this->getPath(detector)
00298                                                 +"/meanTdcOffset");
00299     if(!meanTdcOffsetH) return StatusCode::FAILURE;
00300 
00302     TH1F* adcRawMeanH = m_statsSvc->getTH1F( this->getPath(detector)
00303                                                 +"/adcRawMean");
00304     if(!adcRawMeanH) return StatusCode::FAILURE;
00305     TH1F* adcRawSigmaH = m_statsSvc->getTH1F( this->getPath(detector)
00306                                                 +"/adcRawSigma");
00307     if(!adcRawSigmaH) return StatusCode::FAILURE;
00308     //
00309     TH1F* quasiAdcMeanH = m_statsSvc->getTH1F( this->getPath(detector)
00310                                                 +"/quasiAdcMean");
00311     if(!quasiAdcMeanH) return StatusCode::FAILURE;
00312     TH1F* quasiAdcSigmaH = m_statsSvc->getTH1F( this->getPath(detector)
00313                                                  +"/quasiAdcSigma");
00314     if(!quasiAdcSigmaH) return StatusCode::FAILURE;
00315     //
00316     TH1F* expAdcMeanH = m_statsSvc->getTH1F( this->getPath(detector)
00317                                                   +"/expAdcMean");
00318     if(!expAdcMeanH) return StatusCode::FAILURE;
00319     TH1F* expAdcSigmaH = m_statsSvc->getTH1F( this->getPath(detector)
00320                                                    +"/expAdcSigma");
00321     if(!expAdcSigmaH) return StatusCode::FAILURE;
00322     //
00323     TH1F* preAdcMeanH = m_statsSvc->getTH1F( this->getPath(detector)
00324                                              +"/preAdcMean");
00325     if(!preAdcMeanH) return StatusCode::FAILURE;
00326     TH1F* preAdcSigmaH = m_statsSvc->getTH1F( this->getPath(detector)
00327                                               +"/preAdcSigma");
00328     if(!preAdcSigmaH) return StatusCode::FAILURE;
00329     TH2F* occupancyH2D = m_statsSvc->getTH2F( this->getPath(detector) 
00330                                               + "/occupancy");
00331     if(!occupancyH2D) return StatusCode::FAILURE;
00332     TH2F* gainH2D = m_statsSvc->getTH2F( this->getPath(detector) 
00333                                               + "/gain2D");
00334     if(!gainH2D) return StatusCode::FAILURE;
00335     TH1F* gainH1D = m_statsSvc->getTH1F( this->getPath(detector) 
00336                                               + "/gain1D");
00337     if(!gainH1D) return StatusCode::FAILURE;
00338 
00340     
00341     TObject* simFlagObj = m_statsSvc->get(this->getPath(detector) +"/simFlag");
00342     TParameter<int>* simFlagPar = dynamic_cast<TParameter<int>*>(simFlagObj);
00343     if(!simFlagPar) return StatusCode::FAILURE;
00344 
00345     TObject* timeSecObj = m_statsSvc->get(this->getPath(detector) +"/timeSec");
00346     TParameter<int>* timeSecPar = dynamic_cast<TParameter<int>*>(timeSecObj);
00347     if(!timeSecPar) return StatusCode::FAILURE;
00348 
00349     TObject* timeNanoSecObj = 
00350       m_statsSvc->get(this->getPath(detector) +"/timeNanoSec");
00351     TParameter<int>* timeNanoSecPar = 
00352       dynamic_cast<TParameter<int>*>(timeNanoSecObj);
00353     if(!timeNanoSecPar) return StatusCode::FAILURE;
00354 
00355     Site::Site_t site = detector.site();
00356     DetectorId::DetectorId_t detId = detector.detectorId();
00357     SimFlag::SimFlag_t simFlag = (SimFlag::SimFlag_t)(simFlagPar->GetVal());
00358     time_t timeSec = (time_t)(timeSecPar->GetVal());
00359     int timeNanoSec = timeNanoSecPar->GetVal();
00360     int nReadouts = nReadoutsPar->GetVal();
00361 
00362     // Context, ServiceMode
00363     Context context(site,simFlag,TimeStamp(timeSec,timeNanoSec),detId);
00364     ServiceMode svcMode(context, 0);
00365 
00366     // Prepare data for ring-to-ring comparison
00367     int nRings = 8;
00368     std::map<int,double> meanOccRing;
00369     std::map<int,double> meanOccWeight;
00370     std::map<int,double> meanTdcRing;
00371     std::map<int,double> meanTdcWeight;
00372     for(int ring = 1; ring <= nRings; ring++){
00373       meanOccRing[ring] = 0.0;
00374       meanOccWeight[ring] = 0.0;
00375       meanTdcRing[ring] = 0.0;
00376       meanTdcWeight[ring] = 0.0;
00377     }
00378     double minValidOcc = 0.01;  // Cut on PMTs with bad/low occupancy
00379     std::vector<DayaBay::FeeChannelId> badChannels;
00380 
00381     // Get list of all FEE channels (not from data, but just from cableSvc)
00382     const std::vector<DayaBay::FeeChannelId>& channelList 
00383       = m_cableSvc->feeChannelIds( svcMode );
00384     std::vector<DayaBay::FeeChannelId>::const_iterator chanIter, 
00385       chanEnd = channelList.end();
00386     // Initialize statistics for each channel
00387     for(chanIter = channelList.begin(); chanIter != chanEnd; chanIter++){
00388       DayaBay::FeeChannelId chanId = *chanIter;
00389 
00390       // Analyze the channel data
00391       // Determine ring and column
00392       DayaBay::AdPmtSensor pmtId = 
00393         m_cableSvc->adPmtSensor(chanId, svcMode);
00394       int ring = pmtId.ring();
00395       int column = pmtId.column();
00396 
00397       m_textFile<<-1<<" "<<chanId.board()<<" "<<chanId.connector()<<" ";
00398 
00399       // Channel status
00400       bool occupancyOk = true;
00401       bool gainOk = true;
00402 
00403       // Get Parameters and Histograms
00404       TObject* nHitsObj = m_statsSvc->get(this->getPath(chanId) + "/nHits");
00405       TParameter<int>* nHitsPar = dynamic_cast<TParameter<int>*>(nHitsObj);
00406       if(!nHitsPar) return StatusCode::FAILURE;
00407       TH1F* tdcByMeanH= m_statsSvc->getTH1F( this->getPath(chanId)
00408                                                +"/tdcByMean");
00409       if(!tdcByMeanH) return StatusCode::FAILURE;
00411       TH1F* adcH = m_statsSvc->getTH1F( this->getPath(chanId) + "/adc");
00412       if(!adcH) return StatusCode::FAILURE;
00413       TH1F* adcRawH = m_statsSvc->getTH1F( this->getPath(chanId) + "/adcRaw");
00414       if(!adcRawH) return StatusCode::FAILURE;
00415       TH1F* preAdcH = m_statsSvc->getTH1F( this->getPath(chanId) + "/preAdc");
00416       if(!preAdcH) return StatusCode::FAILURE;
00417       TH1F* quasiAdcH = m_statsSvc->getTH1F( this->getPath(chanId) + "/quasiAdc");
00418       if(!quasiAdcH) return StatusCode::FAILURE;
00419       
00421       TH1F* occupancyH = m_statsSvc->getTH1F( this->getPath(detector,ring)
00422                                               +"/occupancy");
00423       if(!occupancyH) return StatusCode::FAILURE;
00424 
00425       TH1F* tdcOffsetH = m_statsSvc->getTH1F( this->getPath(detector,ring)
00426                                               +"/tdcOffset");
00427       if(!tdcOffsetH) return StatusCode::FAILURE;
00428       TH1F* adcMeanH = m_statsSvc->getTH1F( this->getPath(detector,ring)
00429                                               +"/adcMean");
00430       if(!adcMeanH) return StatusCode::FAILURE;
00431       TH1F* adcSigmaH = m_statsSvc->getTH1F( this->getPath(detector,ring)
00432                                              +"/adcSigma");
00433       if(!adcSigmaH) return StatusCode::FAILURE;
00434 
00435       // Channel Occupancy
00436       double occupancy = 0;
00437       double occupancyUncert = 0;
00438       {
00439         int nHits = nHitsPar->GetVal();
00440         if(nReadouts > 0){
00441           occupancy = nHits / ((double) nReadouts);
00442           occupancyUncert = 
00443             sqrt( occupancy*(1-occupancy)/((double) nReadouts) );
00444         }
00445         occupancyH->SetBinContent(occupancyH->FindBin(column),occupancy);
00446         occupancyH->SetBinError(occupancyH->FindBin(column),occupancyUncert);
00447         occupancyH2D->SetBinContent(occupancyH2D->GetXaxis()->FindBin(column),
00448                                     occupancyH2D->GetYaxis()->FindBin(ring),
00449                                     occupancy);
00450         occupancyH2D->SetBinError(occupancyH2D->GetXaxis()->FindBin(column),
00451                                     occupancyH2D->GetYaxis()->FindBin(ring),
00452                                     occupancyUncert);
00453         
00454         if(occupancy < minValidOcc) occupancyOk = false;
00455       }
00456       // TDC offset
00457       double tdcOffset = 0;
00458       double tdcOffsetUncert = 0;
00459       {
00460         // Use a fit to the leading edge to determine the time offset
00461         int maxbin = tdcByMeanH->GetMaximumBin();
00462         double fitMin = tdcByMeanH->GetBinCenter(maxbin) - 3; //tdcByMeanH->GetRMS(1);
00463         double fitMax = tdcByMeanH->GetBinCenter(maxbin) + 3; //tdcByMeanH->GetRMS(1);
00464         tdcByMeanH->Fit("gaus","","",fitMin, fitMax);
00465         TF1* fitFunc = tdcByMeanH->GetFunction("gaus");
00466         if( fitFunc ){
00467           tdcOffset = fitFunc->GetParameter(1);
00468           tdcOffsetUncert = fitFunc->GetParError(1);
00469           
00470           if( fitFunc->GetNDF() < 3 ) 
00471             // Catch bad fits
00472             tdcOffsetUncert = 0;
00473           else
00474             // Scale uncertainty by the quality of the fit
00475             tdcOffsetUncert *= sqrt(fitFunc->GetChisquare() / fitFunc->GetNDF());
00476           
00477           tdcOffsetH->SetBinContent(tdcOffsetH->FindBin(column),tdcOffset);
00478           tdcOffsetH->SetBinError(tdcOffsetH->FindBin(column),tdcOffsetUncert);
00479         }else{
00480           warning() << "PMT  " << pmtId << " has no TDC data for fitting." 
00481                     << endreq;
00482         }
00483       }
00484 
00485       // PreAdc
00486       double preAdcArea;
00487       double preAdcMean;
00488       double preAdcSigm;
00489       {
00490         preAdcArea = preAdcH->GetEntries();
00491         preAdcMean = preAdcH->GetMean(1);
00492         preAdcSigm = preAdcH->GetRMS(1);
00493         TF1 preAdcFit("preAdcFit","gaus");
00494         preAdcFit.SetParameter( 0, preAdcArea );
00495         preAdcFit.SetParameter( 1, preAdcMean );
00496         preAdcFit.SetParameter( 2, preAdcSigm );
00497         preAdcH->Fit( &preAdcFit, "", "", 
00498                       preAdcMean-2*preAdcSigm, preAdcMean+2*preAdcSigm );
00499         preAdcMean = preAdcFit.GetParameter(1);
00500         preAdcSigm = preAdcFit.GetParameter(2);
00501         //
00502         if(chanId.board()<=16) {
00503           preAdcMeanH->SetBinContent(
00504                                      chanId.board()*16+chanId.connector(),preAdcMean);
00505           preAdcSigmaH->SetBinContent(
00506                                       chanId.board()*16+chanId.connector(),preAdcSigm);
00507         }
00508         
00509         m_textFile<<preAdcMean<<" "<<preAdcSigm<<" ";
00510       }
00511 
00512       // Raw Adc
00513       double adcRawArea;
00514       double adcRawMean;
00515       double adcRawSigm;
00516       {
00517         adcRawArea = adcRawH->GetEntries();
00518         adcRawMean = adcRawH->GetMean(1);
00519         adcRawSigm = adcRawH->GetRMS(1);
00520         TF1 adcRawFit("adcRawFit","gaus");
00521         adcRawFit.SetParameter( 0, adcRawArea );
00522         adcRawFit.SetParameter( 1, adcRawMean );
00523         adcRawFit.SetParameter( 2, adcRawSigm );
00524         adcRawH->Fit( &adcRawFit, "", "",
00525                       adcRawMean-1.0*adcRawSigm, adcRawMean+1.0*adcRawSigm );
00526         adcRawMean = adcRawFit.GetParameter(1);
00527         adcRawSigm = adcRawFit.GetParameter(2);
00528         
00529         if(chanId.board()<=16) {
00530           adcRawMeanH->SetBinContent(
00531                                      chanId.board()*16+chanId.connector(),adcRawMean);
00532           adcRawSigmaH->SetBinContent(
00533                                       chanId.board()*16+chanId.connector(),adcRawSigm);
00534         }
00535 
00536         m_textFile<<adcRawMean<<" "<<adcRawSigm<<" ";
00537       }
00538 
00539       // ADC (Adc -Ave Ped)
00540       double adcArea = 0;
00541       double adcMean = 0;
00542       double adcMeanUncert = 0;
00543       double adcSigma = 0;
00544       double adcSigmaUncert = 0;
00545       {
00546         // Find ADC SPE peak, width with simple gaussian
00547         adcArea = adcH->GetEntries();
00548         adcMean = adcH->GetMean(1);
00549         adcSigma= adcH->GetRMS(1);
00550         TF1 adcFit("adcFit","gaus");
00551         adcFit.SetParameter( 0, adcArea );
00552         adcFit.SetParameter( 1, adcMean );
00553         adcFit.SetParameter( 2, adcSigma);
00554         adcH->Fit( &adcFit,"","",
00555                    adcMean-1.0*adcSigma, adcMean+1.0*adcSigma); 
00556 
00557         adcMean = adcFit.GetParameter(1);
00558         adcMeanUncert = adcFit.GetParError(1);
00559         adcSigma = adcFit.GetParameter(2);
00560         adcSigmaUncert = adcFit.GetParError(2);
00561         gainOk=true;
00562 
00563         adcMeanH->SetBinContent(adcMeanH->FindBin(column),adcMean);
00564         adcMeanH->SetBinError(adcMeanH->FindBin(column),adcMeanUncert);
00565         adcSigmaH->SetBinContent(adcSigmaH->FindBin(column),adcSigma);
00566         adcSigmaH->SetBinError(adcSigmaH->FindBin(column),adcSigmaUncert);
00567         gainH2D->SetBinContent(gainH2D->GetXaxis()->FindBin(column),
00568                                gainH2D->GetYaxis()->FindBin(ring),
00569                                adcMean);
00570         gainH2D->SetBinError(gainH2D->GetXaxis()->FindBin(column),
00571                                gainH2D->GetYaxis()->FindBin(ring),
00572                                adcMeanUncert);
00573         gainH1D->Fill(adcMean);
00574 
00575         if(chanId.board()<=16) {
00576           expAdcMeanH->SetBinContent(
00577                                      chanId.board()*16+chanId.connector(),adcMean);
00578           expAdcSigmaH->SetBinContent(
00579                                       chanId.board()*16+chanId.connector(),adcSigma);
00580         }
00581 
00582         m_textFile<<adcMean<<" "<<adcSigma<<" ";
00583       }
00584 
00585       // Quasi Adc
00586       double quasiAdcArea;
00587       double quasiAdcMean;
00588       double quasiAdcSigm;
00589       {
00590         quasiAdcArea = quasiAdcH->GetEntries();
00591         quasiAdcMean = quasiAdcH->GetMean(1);
00592         quasiAdcSigm = quasiAdcH->GetRMS(1);
00593         TF1 quasiAdcFit("quasiAdcFit","gaus");
00594         quasiAdcFit.SetParameter( 0, quasiAdcArea );
00595         quasiAdcFit.SetParameter( 1, quasiAdcMean );
00596         quasiAdcFit.SetParameter( 2, quasiAdcSigm );
00597         quasiAdcH->Fit( &quasiAdcFit, "", "",
00598                         quasiAdcMean-1.0*quasiAdcSigm, quasiAdcMean+1.0*quasiAdcSigm );
00599         quasiAdcMean = quasiAdcFit.GetParameter(1);
00600         quasiAdcSigm = quasiAdcFit.GetParameter(2);
00601 
00602         if(chanId.board()<=16) {
00603           quasiAdcMeanH->SetBinContent(
00604                                        chanId.board()*16+chanId.connector(),quasiAdcMean);
00605           quasiAdcSigmaH->SetBinContent(
00606                                         chanId.board()*16+chanId.connector(),quasiAdcSigm);
00607         }
00608 
00609         m_textFile<<quasiAdcMean<<" "<<quasiAdcSigm<<endl;
00610       }
00611 
00612 
00613       // Record ring averages, ignoring bad channels
00614       if( occupancyOk && gainOk ){
00615         if( occupancyUncert > 0 ){
00616           meanOccRing[ring] += occupancy / (occupancyUncert*occupancyUncert); 
00617           meanOccWeight[ring] += 1.0 / (occupancyUncert*occupancyUncert); 
00618         }
00619         if( tdcOffsetUncert > 0 ){
00620           meanTdcRing[ring] += tdcOffset / (tdcOffsetUncert*tdcOffsetUncert); 
00621           meanTdcWeight[ring] += 1.0 / (tdcOffsetUncert*tdcOffsetUncert); 
00622         }
00623       }
00624 
00625     }
00626 
00627     // Record mean time offset and mean occupancy by ring
00628     for(int ring = 1; ring <= nRings; ring++){
00629       if( meanOccWeight[ring] > 0 ){
00630         meanOccupancyH->SetBinContent(ring,
00631                                       meanOccRing[ring] / meanOccWeight[ring]);
00632         meanOccupancyH->SetBinError(ring, 
00633                                     sqrt( 1.0 / meanOccWeight[ring] ));
00634       }
00635       if( meanTdcWeight[ring] > 0 ){
00636         meanTdcOffsetH->SetBinContent(ring,
00637                                       meanTdcRing[ring] / meanTdcWeight[ring]);
00638         meanTdcOffsetH->SetBinError(ring, 
00639                                     sqrt( 1.0 / meanTdcWeight[ring] ));
00640       }
00641     } // Loop over rings
00642  
00643   } // Loop over detectors
00644   return StatusCode::SUCCESS;
00645 }

bool PmtCalibLeadingEdge::hasStats ( const DayaBay::Detector &  detector  )  [private]

Check if the statistics for this detector have been initialized.

Definition at line 648 of file PmtCalibLeadingEdge.cc.

00648                                                                  {
00649   // Check if statistics have been initialized for this detector
00650   return (std::find(m_processedDetectors.begin(), 
00651                     m_processedDetectors.end(), 
00652                     detector) 
00653           != m_processedDetectors.end());
00654 }

StatusCode PmtCalibLeadingEdge::prepareStats ( const Context &  context  )  [private]

Get the current statistics for a detector, or create if needed.

Definition at line 15 of file PmtCalibLeadingEdgePrepare.cc.

00015                                                                   {
00016   // Create the histograms and parameters for this detector's statistics
00017   DayaBay::Detector detector(context.GetSite(), context.GetDetId());
00018 
00019   // Site
00020   {
00021     std::string name = "site";
00022     std::ostringstream path;
00023     path << this->getPath(detector) << "/" << name;
00024     TParameter<int>* par = new TParameter<int>(name.c_str(), 
00025                                                context.GetSite());
00026     if( m_statsSvc->put(path.str(),par).isFailure() ) {
00027       error() << "prepareStats(): Could not register " << name 
00028               << " at " << path << endreq;
00029       delete par;
00030       par = 0;
00031       return StatusCode::FAILURE;
00032     }
00033   }
00034 
00035   // Detector ID
00036   {
00037     std::string name = "detectorId";
00038     std::ostringstream path;
00039     path << this->getPath(detector) << "/" << name;
00040     TParameter<int>* par = new TParameter<int>(name.c_str(), 
00041                                                context.GetDetId());
00042     if( m_statsSvc->put(path.str(),par).isFailure() ) {
00043       error() << "prepareStats(): Could not register " << name 
00044               << " at " << path << endreq;
00045       delete par;
00046       par = 0;
00047       return StatusCode::FAILURE;
00048     }
00049   }
00050 
00051   // SimFlag
00052   {
00053     std::string name = "simFlag";
00054     std::ostringstream path;
00055     path << this->getPath(detector) << "/" << name;
00056     TParameter<int>* par = new TParameter<int>(name.c_str(), 
00057                                                context.GetSimFlag());
00058     if( m_statsSvc->put(path.str(),par).isFailure() ) {
00059       error() << "prepareStats(): Could not register " << name 
00060               << " at " << path << endreq;
00061       delete par;
00062       par = 0;
00063       return StatusCode::FAILURE;
00064     }
00065   }
00066 
00067   // Timestamp: seconds
00068   {
00069     std::string name = "timeSec";
00070     std::ostringstream path;
00071     path << this->getPath(detector) << "/" << name;
00072     TParameter<int>* par = new TParameter<int>(name.c_str(), 
00073                                                context.GetTimeStamp().GetSec());
00074     if( m_statsSvc->put(path.str(),par).isFailure() ) {
00075       error() << "prepareStats(): Could not register " << name 
00076               << " at " << path << endreq;
00077       delete par;
00078       par = 0;
00079       return StatusCode::FAILURE;
00080     }
00081   }
00082 
00083   // Timestamp: nanoseconds
00084   {
00085     std::string name = "timeNanoSec";
00086     std::ostringstream path;
00087     path << this->getPath(detector) << "/" << name;
00088     TParameter<int>* par = 
00089       new TParameter<int>(name.c_str(), context.GetTimeStamp().GetNanoSec());
00090     if( m_statsSvc->put(path.str(),par).isFailure() ) {
00091       error() << "prepareStats(): Could not register " << name 
00092               << " at " << path << endreq;
00093       delete par;
00094       par = 0;
00095       return StatusCode::FAILURE;
00096     }
00097   }
00098 
00099   // Number of Readouts
00100   {
00101     std::string name = "nReadouts";
00102     std::ostringstream path;
00103     path << this->getPath(detector) << "/" << name;
00104     TParameter<int>* par = new TParameter<int>(name.c_str(), 0);
00105     if( m_statsSvc->put(path.str(),par).isFailure() ) {
00106       error() << "prepareStats(): Could not register " << name 
00107               << " at " << path << endreq;
00108       delete par;
00109       par = 0;
00110       return StatusCode::FAILURE;
00111     }
00112   }
00113 
00115   // NChannel
00116   {
00117     std::ostringstream title, path;
00118     std::string name = "NChannel";
00119     title << "NChannel " << detector.detName();
00120     path << this->getPath(detector) << "/" << name;
00121     TH1F* nchannel = new TH1F(name.c_str(),title.str().c_str(),200,0,200);
00122     nchannel->GetXaxis()->SetTitle("NChannel");
00123     nchannel->GetYaxis()->SetTitle("Entries");
00124     if( m_statsSvc->put(path.str(),nchannel).isFailure() ) {
00125       error() << "prepareStats(): Could not register " << path << endreq;
00126       delete nchannel;
00127       return StatusCode::FAILURE;
00128     }
00129   }
00130   // Raw Adc, mean
00131   {
00132     std::ostringstream title, path;
00133     std::string name = "adcRawMean";
00134     title << "Raw ADC, mean in " << detector.detName();
00135     path << this->getPath(detector) << "/" << name;
00136     TH1F* adcRawMean = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
00137     adcRawMean->GetXaxis()->SetTitle("Ring*24+Column");
00138     adcRawMean->GetYaxis()->SetTitle("Raw ADC mean");
00139     if( m_statsSvc->put(path.str(),adcRawMean).isFailure() ) {
00140       error() << "prepareStats(): Could not register " << path << endreq;
00141       delete adcRawMean;
00142       return StatusCode::FAILURE;
00143     }
00144   }
00145   // Raw Adc, sigma
00146   {
00147     std::ostringstream title, path;
00148     std::string name = "adcRawSigma";
00149     title << "Raw ADC, sigma in " << detector.detName();
00150     path << this->getPath(detector) << "/" << name;
00151     TH1F* adcRawSigma = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
00152     adcRawSigma->GetXaxis()->SetTitle("Ring*24+Column");
00153     adcRawSigma->GetYaxis()->SetTitle("Raw ADC sigma");
00154     if( m_statsSvc->put(path.str(),adcRawSigma).isFailure() ) {
00155       error() << "prepareStats(): Could not register " << path << endreq;
00156       delete adcRawSigma;
00157       return StatusCode::FAILURE;
00158     }
00159   }
00160   // Adc - preAdc, mean
00161   {
00162     std::ostringstream title, path;
00163     std::string name = "quasiAdcMean";
00164     title << "ADC - preAdc, mean in " << detector.detName();
00165     path << this->getPath(detector) << "/" << name;
00166     TH1F* quasiAdcMean = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
00167     quasiAdcMean->GetXaxis()->SetTitle("Ring*24+Column");
00168     quasiAdcMean->GetYaxis()->SetTitle("QuasiAdc mean");
00169     if( m_statsSvc->put(path.str(),quasiAdcMean).isFailure() ) {
00170       error() << "prepareStats(): Could not register " << path << endreq;
00171       delete quasiAdcMean;
00172       return StatusCode::FAILURE;
00173     }
00174   }
00175   // Adc - preAdc, sigma
00176   {
00177     std::ostringstream title, path;
00178     std::string name = "quasiAdcSigma";
00179     title << "ADC - preAdc, sigma in " << detector.detName();
00180     path << this->getPath(detector) << "/" << name;
00181     TH1F* quasiAdcSigma = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
00182     quasiAdcSigma->GetXaxis()->SetTitle("Ring*24+Column");
00183     quasiAdcSigma->GetYaxis()->SetTitle("QuasiAdc sigma");
00184     if( m_statsSvc->put(path.str(),quasiAdcSigma).isFailure() ) {
00185       error() << "prepareStats(): Could not register " << path << endreq;
00186       delete quasiAdcSigma;
00187       return StatusCode::FAILURE;
00188     }
00189   }
00190   // Adc - Ave preAdc, mean
00191   {
00192     std::ostringstream title, path;
00193     std::string name = "expAdcMean";
00194     title << "ADC - ave preAdc, mean in " << detector.detName();
00195     path << this->getPath(detector) << "/" << name;
00196     TH1F* expAdcMean = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
00197     expAdcMean->GetXaxis()->SetTitle("Ring*24+Column");
00198     expAdcMean->GetYaxis()->SetTitle("ExpAdc mean");
00199     if( m_statsSvc->put(path.str(),expAdcMean).isFailure() ) {
00200       error() << "prepareStats(): Could not register " << path << endreq;
00201       delete expAdcMean;
00202       return StatusCode::FAILURE;
00203     }
00204   }
00205   // Adc - Ave preAdc, sigma
00206   {
00207     std::ostringstream title, path;
00208     std::string name = "expAdcSigma";
00209     title << "ADC - ave preAdc, sigma in " << detector.detName();
00210     path << this->getPath(detector) << "/" << name;
00211     TH1F* expAdcSigma = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
00212     expAdcSigma->GetXaxis()->SetTitle("Ring*24+Column");
00213     expAdcSigma->GetYaxis()->SetTitle("ExpAdc sigma");
00214     if( m_statsSvc->put(path.str(),expAdcSigma).isFailure() ) {
00215       error() << "prepareStats(): Could not register " << path << endreq;
00216       delete expAdcSigma;
00217       return StatusCode::FAILURE;
00218     }
00219   }
00220   // preAdc, mean
00221   {
00222     std::ostringstream title, path;
00223     std::string name = "preAdcMean";
00224     title << "preAdc, mean in " << detector.detName();
00225     path << this->getPath(detector) << "/" << name;
00226     TH1F* preAdcMean = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
00227     preAdcMean->GetXaxis()->SetTitle("Ring*24+Column");
00228     preAdcMean->GetYaxis()->SetTitle("preAdc mean");
00229     if( m_statsSvc->put(path.str(),preAdcMean).isFailure() ) {
00230       error() << "prepareStats(): Could not register " << path << endreq;
00231       delete preAdcMean;
00232       return StatusCode::FAILURE;
00233     }
00234   }
00235   // preAdc, sigma
00236   {
00237     std::ostringstream title, path;
00238     std::string name = "preAdcSigma";
00239     title << "preAdc, sigma in " << detector.detName();
00240     path << this->getPath(detector) << "/" << name;
00241     TH1F* preAdcSigma = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
00242     preAdcSigma->GetXaxis()->SetTitle("Ring*24+Column");
00243     preAdcSigma->GetYaxis()->SetTitle("preAdc sigma");
00244     if( m_statsSvc->put(path.str(),preAdcSigma).isFailure() ) {
00245       error() << "prepareStats(): Could not register " << path << endreq;
00246       delete preAdcSigma;
00247       return StatusCode::FAILURE;
00248     }
00249   }
00250     // Occupancy for each channel (jpochoa)
00251     {
00252       std::ostringstream title, path;
00253       std::string name = "occupancy";
00254       title << "Occupancy per channel " << detector.detName();
00255       path << this->getPath(detector) << "/" << name;
00256       TH2F* occupancy = new TH2F(name.c_str(),title.str().c_str(),49,0.25,24.75,19,-0.75,8.75);
00257       occupancy->GetXaxis()->SetTitle("Column");
00258       occupancy->GetYaxis()->SetTitle("Ring");
00259       if( m_statsSvc->put(path.str(),occupancy).isFailure() ) {
00260         error() << "prepareStats(): Could not register " << path << endreq;
00261         delete occupancy;
00262         return StatusCode::FAILURE;
00263       }
00264     }
00265   // Gain for each channel (jpochoa)
00266   {
00267       std::ostringstream title, path;
00268       std::string name = "gain2D";
00269       title << "Gain per channel " << detector.detName();
00270       path << this->getPath(detector) << "/" << name;
00271       TH2F* gain2D = new TH2F(name.c_str(),title.str().c_str(),49,0.25,24.75,19,-0.75,8.75);
00272       gain2D->GetXaxis()->SetTitle("Column");
00273       gain2D->GetYaxis()->SetTitle("Ring");
00274       if( m_statsSvc->put(path.str(),gain2D).isFailure() ) {
00275         error() << "prepareStats(): Could not register " << path << endreq;
00276         delete gain2D;
00277         return StatusCode::FAILURE;
00278       }
00279     }
00280      // Gain for all channels (jpochoa)
00281   {
00282       std::ostringstream title, path;
00283       std::string name = "gain1D";
00284       title << "Gain for all channels " << detector.detName();
00285       path << this->getPath(detector) << "/" << name;
00286       TH1F* gain1D = new TH1F(name.c_str(),title.str().c_str(),50,20,60);
00287       gain1D->GetXaxis()->SetTitle("ADC/PE");
00288       gain1D->GetYaxis()->SetTitle("Number of entries");
00289       if( m_statsSvc->put(path.str(),gain1D).isFailure() ) {
00290         error() << "prepareStats(): Could not register " << path << endreq;
00291         delete gain1D;
00292         return StatusCode::FAILURE;
00293       }
00294     }
00296 
00297   // ADC Sum spectrum
00298   {
00299     std::ostringstream title, path;
00300     std::string name = "adcSum";
00301     title << "ADC Sum for readouts in " << detector.detName(); 
00302     path << this->getPath(detector) << "/" << name;
00303     TH1F* adcSum = new TH1F(name.c_str(),title.str().c_str(),
00304                             2000,0,20000);
00305     adcSum->GetXaxis()->SetTitle("ADC Sum value");
00306     adcSum->GetYaxis()->SetTitle("Entries");
00307     // DEBUG
00308     info() << "name= " << adcSum->GetName() 
00309            << " at path = \"" << path.str() << "\"" << endreq;
00310     if( m_statsSvc->put(path.str(),adcSum).isFailure() ) {
00311       error() << "prepareStats(): Could not register " << path << endreq;
00312       delete adcSum;
00313       return StatusCode::FAILURE;
00314     }
00315   }
00316   // TDC Mean spectrum
00317   {
00318     std::ostringstream title, path;
00319     std::string name = "tdcMean";
00320     title << "Mean TDC for readouts in " << detector.detName(); 
00321     path << this->getPath(detector) << "/" << name;
00322     TH1F* tdcMean = new TH1F(name.c_str(),title.str().c_str(),
00323                                2000,0,2000);
00324     tdcMean->GetXaxis()->SetTitle("TDC value");
00325     tdcMean->GetYaxis()->SetTitle("Entries");
00326     if( m_statsSvc->put(path.str(),tdcMean).isFailure() ) {
00327       error() << "prepareStats(): Could not register " << path << endreq;
00328       delete tdcMean;
00329       return StatusCode::FAILURE;
00330     }
00331   }
00332   // Mean TDC Offset by AD ring
00333   {
00334     std::ostringstream title, path;
00335     std::string name = "meanTdcOffset";
00336     title << "Mean TDC offset by ring in " << detector.detName(); 
00337     path << this->getPath(detector) << "/" << name;
00338     TH1F* meanTdcOffset = new TH1F(name.c_str(),title.str().c_str(),
00339                                    8,1,9);
00340     meanTdcOffset->GetXaxis()->SetTitle("AD Ring");
00341     meanTdcOffset->GetYaxis()->SetTitle("Mean TDC Offset");
00342     if( m_statsSvc->put(path.str(),meanTdcOffset).isFailure() ) {
00343       error() << "prepareStats(): Could not register " << path << endreq;
00344       delete meanTdcOffset;
00345       return StatusCode::FAILURE;
00346     }
00347   }
00348   // Mean Occupancy by AD ring
00349   {
00350     std::ostringstream title, path;
00351     std::string name = "meanOccupancy";
00352     title << "Mean occupancy by ring in " << detector.detName(); 
00353     path << this->getPath(detector) << "/" << name;
00354     TH1F* meanOccupancy = new TH1F(name.c_str(),title.str().c_str(),
00355                                    8,1,9);
00356     meanOccupancy->GetXaxis()->SetTitle("AD Ring");
00357     meanOccupancy->GetYaxis()->SetTitle("Mean Occupancy");
00358     if( m_statsSvc->put(path.str(),meanOccupancy).isFailure() ) {
00359       error() << "prepareStats(): Could not register " << path << endreq;
00360       delete meanOccupancy;
00361       return StatusCode::FAILURE;
00362     }
00363   }
00364 
00365   // Make sure summary histograms for each ring exist in detector statistics
00366   for(int ring = 0; ring <= 8; ring++){
00367     // Occupancy by ring
00368     {
00369       std::ostringstream title, path;
00370       std::string name = "occupancy";
00371       title << "Occupancy for PMTs in " << detector.detName() 
00372             << " ring " << ring; 
00373       path << this->getPath(detector, ring) << "/" << name;
00374       TH1F* occupancy = new TH1F(name.c_str(),title.str().c_str(),
00375                                  24,1,25);
00376       occupancy->GetXaxis()->SetTitle("Column");
00377       occupancy->GetYaxis()->SetTitle("Occupancy");
00378       if( m_statsSvc->put(path.str(),occupancy).isFailure() ) {
00379         error() << "prepareStats(): Could not register " << path << endreq;
00380         delete occupancy;
00381         return StatusCode::FAILURE;
00382       }
00383     }
00384     // TDC offset by ring
00385     {
00386       std::ostringstream title, path;
00387       std::string name = "tdcOffset";
00388       title << "Time Offset for PMTs in " << detector.detName() 
00389             << " ring " << ring; 
00390       path << this->getPath(detector, ring) << "/" << name;
00391       TH1F* tdcOffset = new TH1F(name.c_str(),title.str().c_str(),
00392                            24,1,25);
00393       tdcOffset->GetXaxis()->SetTitle("Column");
00394       tdcOffset->GetYaxis()->SetTitle("Time Offset [tdc]");
00395       if( m_statsSvc->put(path.str(),tdcOffset).isFailure() ) {
00396         error() << "prepareStats(): Could not register " << path << endreq;
00397         delete tdcOffset;
00398         return StatusCode::FAILURE;
00399       }
00400     }
00401     // ADC Mean by ring
00402     {
00403       std::ostringstream title, path;
00404       std::string name = "adcMean";
00405       title << "ADC Mean for PMTs in " << detector.detName() 
00406             << " ring " << ring; 
00407       path << this->getPath(detector, ring) << "/" << name;
00408       TH1F* adcMean = new TH1F(name.c_str(),title.str().c_str(),
00409                                  24,1,25);
00410       adcMean->GetXaxis()->SetTitle("Column");
00411       adcMean->GetYaxis()->SetTitle("Mean ADC");
00412       if( m_statsSvc->put(path.str(),adcMean).isFailure() ) {
00413         error() << "prepareStats(): Could not register " << path << endreq;
00414         delete adcMean;
00415         return StatusCode::FAILURE;
00416       }
00417     }
00418     // ADC Sigma by ring
00419     {
00420       std::ostringstream title, path;
00421       std::string name = "adcSigma";
00422       title << "ADC Sigma for PMTs in " << detector.detName() 
00423             << " ring " << ring;
00424       path << this->getPath(detector, ring) << "/" << name;
00425       TH1F* adcSigma = new TH1F(name.c_str(),title.str().c_str(),
00426                                 24,1,25);
00427       adcSigma->GetXaxis()->SetTitle("Column");
00428       adcSigma->GetYaxis()->SetTitle("ADC Sigma");
00429       if( m_statsSvc->put(path.str(),adcSigma).isFailure() ) {
00430         error() << "prepareStats(): Could not register " << path << endreq;
00431         delete adcSigma;
00432         return StatusCode::FAILURE;
00433       }
00434     }
00435   }
00436 
00437   ServiceMode svcMode(context, 0);
00438 
00439   // Get list of all FEE channels
00440   const std::vector<DayaBay::FeeChannelId>& channelList 
00441     = m_cableSvc->feeChannelIds( svcMode );
00442   std::vector<DayaBay::FeeChannelId>::const_iterator chanIter, 
00443     chanEnd = channelList.end();
00444   // Initialize statistics for each channel
00445   for(chanIter = channelList.begin(); chanIter != chanEnd; chanIter++){
00446     DayaBay::FeeChannelId chanId = *chanIter;
00447 
00448     // Board Number
00449     {
00450       std::string name = "board";
00451       std::ostringstream path;
00452       path << this->getPath(chanId) << "/" << name;
00453       TParameter<int>* par = new TParameter<int>(name.c_str(), chanId.board());
00454       if( m_statsSvc->put(path.str(),par).isFailure() ) {
00455         error() << "prepareStats(): Could not register " << name 
00456                 << " at " << path << endreq;
00457         delete par;
00458         par = 0;
00459         return StatusCode::FAILURE;
00460       }
00461     }
00462 
00463     // Connector Number
00464     {
00465       std::string name = "connector";
00466       std::ostringstream path;
00467       path << this->getPath(chanId) << "/" << name;
00468       TParameter<int>* par = new TParameter<int>(name.c_str(), 
00469                                                  chanId.connector());
00470       if( m_statsSvc->put(path.str(),par).isFailure() ) {
00471         error() << "prepareStats(): Could not register " << name 
00472                 << " at " << path << endreq;
00473         delete par;
00474         par = 0;
00475         return StatusCode::FAILURE;
00476       }
00477     }
00478 
00479     // Number of Hits
00480     {
00481       std::string name = "nHits";
00482       std::ostringstream path;
00483       path << this->getPath(chanId) << "/" << name;
00484       TParameter<int>* par = new TParameter<int>(name.c_str(), 0);
00485       if( m_statsSvc->put(path.str(),par).isFailure() ) {
00486         error() << "prepareStats(): Could not register " << name 
00487                 << " at " << path << endreq;
00488         delete par;
00489         par = 0;
00490         return StatusCode::FAILURE;
00491       }
00492     }
00493 
00494     // Raw TDC spectrum
00495     {
00496       std::string name = "tdcRaw";
00497       std::ostringstream title, path;
00498       title << "Raw TDC values for " << detector.detName() 
00499             << " channel " << chanId.board() << "_"
00500             << chanId.connector();
00501       path << this->getPath(chanId) << "/" << name;
00502       TH1F* tdcRaw = new TH1F(name.c_str(),title.str().c_str(),
00503                               2000,0,2000);
00504       tdcRaw->GetXaxis()->SetTitle("TDC value");
00505       tdcRaw->GetYaxis()->SetTitle("Entries");
00506       if( m_statsSvc->put(path.str(),tdcRaw).isFailure() ) {
00507         error() << "prepareStats(): Could not register " << path << endreq;
00508         delete tdcRaw;
00509         return StatusCode::FAILURE;
00510       }
00511     }
00512 
00513     // TDC spectrum, mean corrected
00514     {
00515       std::string name = "tdcByMean";
00516       std::ostringstream title, path;
00517       title << "Mean-corrected TDC values for " << detector.detName() 
00518             << " channel " << chanId.board() << "_"
00519             << chanId.connector();
00520       path << this->getPath(chanId) << "/" << name;
00521       TH1F* tdcByMean = new TH1F(name.c_str(),title.str().c_str(),
00522                                    600,-300,300);
00523       tdcByMean->GetXaxis()->SetTitle("TDC value");
00524       tdcByMean->GetYaxis()->SetTitle("Entries");
00525       if( m_statsSvc->put(path.str(),tdcByMean).isFailure() ) {
00526         error() << "prepareStats(): Could not register " << path << endreq;
00527         delete tdcByMean;
00528         return StatusCode::FAILURE;
00529       }
00530     }
00531 
00532     // Raw ADC spectrum
00533     {
00534       std::ostringstream title, path;
00535       std::string name = "adcRaw";
00536       title << "ADC values for " << detector.detName() 
00537             << " channel " << chanId.board() << "_"
00538             << chanId.connector();
00539       path << this->getPath(chanId) << "/" << name;
00540       TH1F* adcRaw = new TH1F(name.c_str(),title.str().c_str(),
00541                               4096,0,4096);
00542       adcRaw->GetXaxis()->SetTitle("ADC value");
00543       adcRaw->GetYaxis()->SetTitle("Entries");
00544       if( m_statsSvc->put(path.str(),adcRaw).isFailure() ) {
00545         error() << "prepareStats(): Could not register " << path << endreq;
00546         delete adcRaw;
00547         return StatusCode::FAILURE;
00548       }
00549     }
00550     
00551     // Quasi ADC spectrum, baseline subtracted ( -preAdc)
00552     {
00553       std::ostringstream title, path;
00554       std::string name = "quasiAdc";
00555       title << "ADC - preAdc " << detector.detName()
00556             << " channel " << chanId.board() << "_"
00557             << chanId.connector();
00558       path << this->getPath(chanId) << "/" << name;
00559       TH1F* quasiAdc = new TH1F(name.c_str(),title.str().c_str(),
00560                            1200,-200,1000);
00561       quasiAdc->GetXaxis()->SetTitle("QuasiADC value");
00562       quasiAdc->GetYaxis()->SetTitle("Entries");
00563       if( m_statsSvc->put(path.str(),quasiAdc).isFailure() ) {
00564         error() << "prepareStats(): Could not register " << path << endreq;
00565         delete quasiAdc;
00566         return StatusCode::FAILURE;
00567       }
00568     }    
00569 
00570     // ADC spectrum, average pedestal substracted
00571     {
00572       std::ostringstream title, path;
00573       std::string name = "adc";
00574       title << "ADC - Average preAdc " << detector.detName() 
00575             << " channel " << chanId.board() << "_"
00576             << chanId.connector();
00577       path << this->getPath(chanId) << "/" << name;
00578       TH1F* adc = new TH1F(name.c_str(),title.str().c_str(),
00579                            1200,-200,1000);
00580       adc->GetXaxis()->SetTitle("ADC value");
00581       adc->GetYaxis()->SetTitle("Entries");
00582       if( m_statsSvc->put(path.str(),adc).isFailure() ) {
00583         error() << "prepareStats(): Could not register " << path << endreq;
00584         delete adc;
00585         return StatusCode::FAILURE;
00586       }
00587     }
00588 
00589     // PreADC spectrum, baseline subtracted
00590     {
00591       std::ostringstream title, path;
00592       std::string name = "preAdc";
00593       title << "PreADC values for " << detector.detName()
00594             << " channel " << chanId.board() << "_"
00595             << chanId.connector();
00596       path << this->getPath(chanId) << "/" << name;
00597       TH1F* preAdc = new TH1F(name.c_str(),title.str().c_str(),
00598                            1200,-200,1000);
00599       preAdc->GetXaxis()->SetTitle("PreADC value");
00600       preAdc->GetYaxis()->SetTitle("Entries");
00601       if( m_statsSvc->put(path.str(),preAdc).isFailure() ) {
00602         error() << "prepareStats(): Could not register " << path << endreq;
00603         delete preAdc;
00604         return StatusCode::FAILURE;
00605       }
00606     }
00607 
00608     // ADC spectrum by Clock Cycle
00609     {
00610       std::ostringstream title, path;
00611       std::string name = "adcByClock";
00612       title << "ADC values by clock cycle for " << detector.detName() 
00613             << " channel " << chanId.board() << "_"
00614             << chanId.connector();
00615       path << this->getPath(chanId) << "/" << name;
00616       TH1F* adcByClock = new TH1F(name.c_str(),title.str().c_str(),
00617                                   20,0,20);
00618       adcByClock->GetXaxis()->SetTitle("ADC Clock Cycle");
00619       adcByClock->GetYaxis()->SetTitle("ADC");
00620       if( m_statsSvc->put(path.str(),adcByClock).isFailure() ) {
00621         error() << "prepareStats(): Could not register " << path << endreq;
00622         delete adcByClock;
00623         return StatusCode::FAILURE;
00624       }
00625     }
00626   }  
00627 
00628   m_processedDetectors.push_back(detector);
00629 
00630   return StatusCode::SUCCESS;
00631 }

std::string PmtCalibLeadingEdge::getPath ( const DayaBay::Detector &  detector  )  [private]

Definition at line 656 of file PmtCalibLeadingEdge.cc.

00656                                                                        {
00657   return m_filepath + "/" + detector.detName();
00658 }

std::string PmtCalibLeadingEdge::getPath ( const DayaBay::Detector &  detector,
int  ring 
) [private]

Definition at line 660 of file PmtCalibLeadingEdge.cc.

00661                                                   {
00662   std::ostringstream path;
00663   path << m_filepath << "/" << detector.detName() << "/ring_" << ring; 
00664   return path.str();
00665 }

std::string PmtCalibLeadingEdge::getPath ( const DayaBay::FeeChannelId &  channelId  )  [private]

Definition at line 667 of file PmtCalibLeadingEdge.cc.

00667                                                                        {
00668   std::ostringstream path;
00669   path << m_filepath << "/" << chanId.detName() 
00670        << "/chan_" << chanId.board() << "_" << chanId.connector(); 
00671   return path.str();
00672 }

bool PmtCalibLeadingEdge::GoodTdc ( int  Tdc  )  [inline, private]

Definition at line 110 of file PmtCalibLeadingEdge.h.

00111     {
00112       if(Tdc>900&&Tdc<1050) return true;
00113       else return false;
00114     };

const InterfaceID & IPmtCalibParamTool::interfaceID (  )  [static, inherited]

Retrieve interface ID.

Reimplemented from IAlgTool.

Definition at line 8 of file IPmtCalibParamTool.cc.

00009 { 
00010     return IID_IPmtCalibParamTool; 
00011 }

Member Data Documentation

std::string PmtCalibLeadingEdge::m_cableSvcName [private]

Definition at line 114 of file PmtCalibLeadingEdge.h.

std::string PmtCalibLeadingEdge::m_calibSvcName [private]

Definition at line 122 of file PmtCalibLeadingEdge.h.

std::string PmtCalibLeadingEdge::m_floatFeePedesSvcName [private]

Definition at line 125 of file PmtCalibLeadingEdge.h.

std::string PmtCalibLeadingEdge::m_filepath [private]

Definition at line 128 of file PmtCalibLeadingEdge.h.

ICableSvc* PmtCalibLeadingEdge::m_cableSvc [private]

Definition at line 131 of file PmtCalibLeadingEdge.h.

ICalibDataSvc* PmtCalibLeadingEdge::m_calibSvc [private]

Definition at line 134 of file PmtCalibLeadingEdge.h.

IStatisticsSvc* PmtCalibLeadingEdge::m_statsSvc [private]

Definition at line 137 of file PmtCalibLeadingEdge.h.

IFloatingFeePedestalSvc* PmtCalibLeadingEdge::m_floatFeePedesSvc [private]

Definition at line 140 of file PmtCalibLeadingEdge.h.

bool PmtCalibLeadingEdge::m_useFloatFeePedes [private]

Definition at line 143 of file PmtCalibLeadingEdge.h.

std::vector<DayaBay::Detector> PmtCalibLeadingEdge::m_processedDetectors [private]

Definition at line 146 of file PmtCalibLeadingEdge.h.

ofstream PmtCalibLeadingEdge::m_textFile [private]

Definition at line 149 of file PmtCalibLeadingEdge.h.

string PmtCalibLeadingEdge::m_textFileName [private]

Definition at line 150 of file PmtCalibLeadingEdge.h.

The documentation for this class was generated from the following files:
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |
Generated on Mon Apr 11 20:29:41 2011 for CalibParam by doxygen 1.4.7