/search.css" rel="stylesheet" type="text/css"/> /search.js">
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

In This Package:

Public Member Functions | Static Public Member Functions | Private Attributes
SimpPmtCalibTool Class Reference

#include <SimpPmtCalibTool.h>

Inheritance diagram for SimpPmtCalibTool:
Inheritance graph
[legend]
Collaboration diagram for SimpPmtCalibTool:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 SimpPmtCalibTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual ~SimpPmtCalibTool ()
virtual StatusCode calibration (const DayaBay::DaqCrate *, DayaBay::CalibReadout *)
 This is the extension. Sub classes must provide it.
virtual StatusCode initialize ()
virtual StatusCode finalize ()

Static Public Member Functions

static const InterfaceID & interfaceID ()
 Retrieve interface ID.

Private Attributes

std::string m_calibDataSvcName
IPmtCalibSvcm_calibDataSvc
std::string m_cableSvcName
bool m_useDynamicPedestal
bool m_useDynamicChgCorr
bool m_useUncalibratedCharge
bool m_useUncalibratedTime
bool m_calibCloselySpacedHits
ICableSvcm_cableSvc
std::string m_ChannelQualitySvcName
IChannelQualitySvcm_chanqualSvc
std::auto_ptr< DynChgCorrUtilm_dynChgCorr
double * m_basePed
int bogusCount
std::map
< DayaBay::FeeChannelId, int > 
m_bogus_pmt
int nodbCount
std::map
< DayaBay::DetectorSensor, int > 
m_nodb_pmt
int notmCount
std::map
< DayaBay::DetectorSensor, int > 
m_notm_pmt
int badstatCount
std::map
< DayaBay::DetectorSensor, int > 
m_badstat_pmt
int nocqCount

Detailed Description

Definition at line 32 of file SimpPmtCalibTool.h.


Constructor & Destructor Documentation

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

Definition at line 42 of file SimpPmtCalibTool.cc.

  :  GaudiTool(type, name, parent)
  ,  m_calibDataSvc(0)
  ,  m_cableSvc(0)
  ,  m_chanqualSvc(0)
{
  declareInterface< ICalibTool >(this);
  declareProperty("CalibDataSvcName", m_calibDataSvcName = "DybPmtCalibSvc",
                  "Name of Pmt calibration data Service");
  declareProperty("CableSvcName", m_cableSvcName = "CableSvc",
                  "Name of Cable Service");
  declareProperty("UseDynamicPedestal", m_useDynamicPedestal=true, 
                  "Use pedestal value embedded with each hit"); 
  declareProperty("UseDynamicChgCorr", m_useDynamicChgCorr=false,
                  "Use dynamic charge correction for closely spaced hits (experimental)");
  declareProperty("UseUncalibratedCharge", m_useUncalibratedCharge=false, 
                  "Use approximate charge calibration"); 
  declareProperty("UseUncalibratedTime", m_useUncalibratedTime=false, 
                  "Use approximate time calibration"); 
  declareProperty("CalibCloselySpacedHits", m_calibCloselySpacedHits=true, 
                  "Calibration of closely spaced hits"); 
  declareProperty("ChannelQualitySvcName", m_ChannelQualitySvcName="DybChannelQualitySvc",
                  "Name of channel quality service");
}
SimpPmtCalibTool::~SimpPmtCalibTool ( ) [virtual]

Definition at line 69 of file SimpPmtCalibTool.cc.

{}

Member Function Documentation

StatusCode SimpPmtCalibTool::calibration ( const DayaBay::DaqCrate ,
DayaBay::CalibReadout  
) [virtual]

This is the extension. Sub classes must provide it.

Implements ICalibTool.

Definition at line 174 of file SimpPmtCalibTool.cc.

{
  debug() << "running calibration() " << endreq;
  StatusCode sc;
  
  // Convert to PMT crate readout
  const DayaBay::DaqPmtCrate* pmtReadout = readout->asPmtCrate();
  if(!pmtReadout){
    error() << "calibration():  no pmt readouts." << endreq;
    return StatusCode::FAILURE;
  }
  
  DayaBay::CalibReadoutPmtCrate* calibReadoutCrate 
    = dynamic_cast<DayaBay::CalibReadoutPmtCrate*>(calibReadout);
  // Check CalibReadoutCrate
  if(calibReadoutCrate == NULL) {
    error() << "calibration():  no calib pmt readouts." << endreq;
    return StatusCode::FAILURE;
  }
  
  const std::vector<DayaBay::DaqPmtChannel*>& channels 
    = pmtReadout->channelReadouts();
  std::vector<DayaBay::DaqPmtChannel*>::const_iterator channelIter, 
    channelEnd = channels.end();
  
  int task = 0;
  Context context = calibReadoutCrate->header()->context();
  ServiceMode svcMode(context, task);
  int task_gain=1;//<---need to query CalibPmtFineGain with task=1, except for dry-runs and MC constants which still have task=0
  if(context.GetSimFlag()==SimFlag::kMC){
    task_gain=0;
  } 
  if(context.GetSite()==Site::kSAB){
    task_gain=0;
  }
  ServiceMode svcModeGain(context, task_gain); 

  
  // Get ChannelQualityService

  DetectorId::DetectorId_t detectorId = context.GetDetId();
  
  const IChannelQuality * cq = 0;
  if (detectorId!=DetectorId::kIWS && detectorId!=DetectorId::kOWS){ // not used for WP for now
    cq = m_chanqualSvc->channelQuality(svcMode);
    if (!cq){
      nocqCount ++;
      if (nocqCount <= NOCQ_ERRORS){
        //      error() << "\tGot null channel quality object for " << context.AsString() << endreq;
        //      return StatusCode::FAILURE;
        warning() << "\tGot null channel quality object for " << context.AsString()
                  << ". Assuming all channels are good." << endreq;
      }
      if (nocqCount == NOCQ_ERRORS){
        warning() << "\tFurther warning for channel quality service will be suppressed" << endreq;
      }
    }
  }
  
  
  double lastAdc = 0;  // set for removing duplicated hits
  
  // Simple calibration channel by channel
  for(channelIter = channels.begin();
      channelIter!=channelEnd; 
      channelIter++){ 
    const DayaBay::DaqPmtChannel* channel = *channelIter; 
    DayaBay::FeeChannelId channelId = channel->channelId();
    
    double lastTdc = 0;  // set for Calibration of closely spaced hits
    double lastAdc = 0;  // set for Calibration of closely spaced hits
    double lastAdcBaseline = 0;          // set for Calibration of closely spaced hits
    double timeSinceLastHit = 0;         // set for Calibration of closely spaced hits
    
    // Get pmt calib data from CalibDataSvc
    DayaBay::DetectorSensor sensDetId 
      = m_cableSvc->sensor(channelId, svcMode);
    bool isbogus=false;//see ticket #1193; have to create child objects to properly determine bogosity
    if(sensDetId.isAD()){
      DayaBay::AdPmtSensor pmtId(sensDetId.fullPackedData());
      if(pmtId.bogus()) isbogus=true;
    }
    else if(sensDetId.isWaterShield()){
      DayaBay::PoolPmtSensor pmtId(sensDetId.fullPackedData());
      if(pmtId.bogus()) isbogus=true;
    }
    
    //Handling bogus PMTs
    if (isbogus) {
      bogusCount++;
      //-->keeping a record     
      std::map<DayaBay::FeeChannelId, int>::iterator result = m_bogus_pmt.find(channelId);
      if(result == m_bogus_pmt.end()) 
        m_bogus_pmt[channelId]=1;
      else {
        m_bogus_pmt[channelId]+=1;
      }
      //-->printing to screen
      if(bogusCount<BOGUS_ERRORS){
        warning() << "Got bogus PMT: \"" << sensDetId
                  << "\" using channelId: \"" << channelId
                  << "\" and context \"" << context.AsString() << "\""
                  << endreq;
      }
      if(bogusCount==BOGUS_ERRORS){
        warning() << "No more bogus PMT warnings will be reported" << endreq;
      }
      // Skip bogus channels; don't add noise/junk/etc. to calibrated readout.
      continue;
    }

    //       //Ignore PMT if its status is not good (jpochoa)
    //  if( pmtCalib->m_status != PmtCalibData::kGood ){
    // Replaced with the previous criteria with the new ChannelQualityService (Yasu)
    // See ticket #1369. Moved this block here on Aug 2013, so that bad channels do not get incorporated into the CalibReadout (jpochoa)
    
    if (detectorId!=DetectorId::kIWS && detectorId!=DetectorId::kOWS){ // not used for WP for now
      DayaBay::AdPmtSensor pmtId(sensDetId.fullPackedData());
      if (pmtId.is8inch() && cq){ // currently, channelquality is set only for 8-inch PMTs
        if(!cq->good(channelId)){
          
          badstatCount+=1;
          
          //-->keeping a record
          std::map<DayaBay::DetectorSensor, int>::iterator result = m_badstat_pmt.find(sensDetId);
          if(result == m_badstat_pmt.end()) 
            m_badstat_pmt[sensDetId]=1;
          else {
            m_badstat_pmt[sensDetId]+=1;
          }
          
          //-->printing to screen 
          if(badstatCount<BADSTATUS_ERRORS){
            warning() << "Bad status: the following PMT " << sensDetId << " does not have a 'good' status in the database for context " << context.AsString() << ". This channel's information will not be recorded in the calibrated readout." << endreq;
          }
          if(badstatCount==BADSTATUS_ERRORS){
            warning() << "No more 'PMT bad status' errors will be reported. Please see summary at the end." << endreq;
          }
          
          //skip bad status channel; don't add noise to calibrated readout (jpochoa)
          continue;
        }//pmt status no good
      }
    }
    
    calibReadoutCrate->addSensor(sensDetId);
    DayaBay::CalibReadoutPmtChannel& cro_ch 
      = *(calibReadoutCrate->sensor(sensDetId)); 
    
    //const DayaBay::PmtCalibData* pmtCalib = 0;
    const DayaBay::FineGainCalibData* fineGainCalib = 0;
    const DayaBay::TimingCalibData* timingCalib = 0;
    if(!m_useUncalibratedCharge || !m_useUncalibratedTime){
      //pmtCalib = m_calibDataSvc->pmtCalibData(sensDetId, svcMode);
      fineGainCalib = m_calibDataSvc->fineGainCalibData(channelId, svcModeGain);
      timingCalib = m_calibDataSvc->timingCalibData(channelId, svcMode);
      //If not gain calibration this PMT will not make it to the CalibreadoutHeader. The same is not true for timing though
      if(!fineGainCalib) {
        nodbCount+=1;
        //-->keeping a record
        std::map<DayaBay::DetectorSensor, int>::iterator result = m_nodb_pmt.find(sensDetId);
        if(result == m_nodb_pmt.end()) 
          m_nodb_pmt[sensDetId]=1;
        else {
          m_nodb_pmt[sensDetId]+=1;
        }
        
        //-->printing to screen 
        if(nodbCount<NODB_ERRORS){
          warning() << "No gain calibration properties for PMT: " << sensDetId 
                    << " for context " << context.AsString()
                    << ", ignoring."<< endreq;
          if(nodbCount==NODB_ERRORS){
            warning() << "You better be processing a FEE self-test file..."
                      << "No more errors will be reported. " << endreq;
          }
        }
        continue;
      }//no gain calib data
    }

    //If not timing calibration just print a warning and a summary, but still process
    if(!timingCalib) {
        notmCount+=1;
        //-->keeping a record
        std::map<DayaBay::DetectorSensor, int>::iterator result = m_notm_pmt.find(sensDetId);
        if(result == m_notm_pmt.end()) 
          m_notm_pmt[sensDetId]=1;
        else {
          m_notm_pmt[sensDetId]+=1;
        }
        
        //-->printing to screen 
        if(notmCount<NODB_ERRORS){
          warning() << "No timing calibration properties for channel: " << sensDetId 
                    << " for context " << context.AsString()
                    << ", ignoring."<< endreq;
          if(notmCount==NODB_ERRORS){
            warning() << "You better be processing a FEE self-test file..."
                      << "No more errors will be reported. " << endreq;
          }
        }
        // continue;
      }//no timing calib data
    
    if(!m_useDynamicPedestal){ 
      error() << "Pedestal from FeeCalibSpec table not supported; use dynamic pedestal instead. " << endreq;
      return StatusCode::FAILURE;
    }

    TimeStamp trigTime = pmtReadout->triggerTime(); // for DynChgCorrUtil
    
    // simple tdc calibration
    std::vector<double> calib_time;
    std::vector<double> calib_charge;
    double tdcToTime = -(1.0/DayaBay::TdcFrequencyHz) * Units::second;
    for(unsigned int hitIdx=0; hitIdx<channel->hitCount(); hitIdx++){

      // Convert TDC to nanoseconds, and remove time-offset + time-walk
      double calibTime = channel->tdc(hitIdx) * tdcToTime; 
      double hitCharge=channel->adc(hitIdx) - channel->preAdcAvg(hitIdx);
      if(!channel->isHighGainAdc(hitIdx)){
        hitCharge*=CoarseAdcFactor;
      }
      double correction = 0;
      if(timingCalib && !m_useUncalibratedTime){
        if(hitCharge>0){
          correction=timingCalib->m_par0+
            timingCalib->m_par1*exp(-1*hitCharge*timingCalib->m_par2)+
            timingCalib->m_par3*exp(-1*hitCharge*timingCalib->m_par4)+
            timingCalib->m_par5*log(hitCharge);
        } 
        else {
          correction=timingCalib->m_par0+
            timingCalib->m_par1+
            timingCalib->m_par3;
        }
      }
      calibTime -= correction;
      
      calib_time.push_back( calibTime ); 

      double adcBaseline = 0.;
      double adcToSpe = 0.;
      if(channel->adc(hitIdx)==0) {
        // Catch invalid ADC values, set to zero charge
        calib_charge.push_back(0.);
        continue;
      }
      // Find ADC pedestal for this channel 
      if(m_useDynamicPedestal){
        adcBaseline = channel->preAdcAvg(hitIdx); 
      }else{
        error() << "Pedestal from FeeCalibSpec table not supported; use dynamic pedestal instead. " << endreq;
        return StatusCode::FAILURE;
      }
      
      // Find ADC to charge conversion
      if(m_useUncalibratedCharge){
        // Use mean charge conversion, instead of PMT calibration parameters
        adcToSpe = 1. / 20.;
        if(! channel->isHighGainAdc(hitIdx) ) adcToSpe = 1.0;
      }else{
        // Use PMT calibration parameters
        if(channel->isHighGainAdc(hitIdx)) {  //high
          adcToSpe = 1.0 / fineGainCalib->m_speHigh;
        }else{
          adcToSpe = 1.0 / (fineGainCalib->m_speHigh*1./CoarseAdcFactor);
        }
      }
      
      // Calibration of closely spaced hits
      if (!m_calibCloselySpacedHits) {
        calib_charge.push_back( (channel->adc(hitIdx) - adcBaseline) * adcToSpe);
      }else{
        int candiTdc = channel->tdc(hitIdx);
        int candiAdc = channel->adc(hitIdx);
        if( lastTdc > candiTdc ) timeSinceLastHit = (lastTdc - candiTdc) * tdcToTime * (-1.0) ;
        if( lastTdc == 0){  
          // CASE 1: is the fist hit on PMT.  Calibrate hit as usual.
          calib_charge.push_back((channel->adc(hitIdx) -adcBaseline) * adcToSpe);
        }else if( timeSinceLastHit < 100  ){  
          // CASE 2: time since last hit < 100 ns. Set calibrated charge to 0.
          if(lastAdc==candiAdc){
            calib_charge.push_back(0);
          }else{
            calib_charge.push_back((channel->adc(hitIdx) -adcBaseline) * adcToSpe);
          }
        }else{  // time since last hit > 100 ns
          adcBaseline = lastAdcBaseline;
          if(lastAdc==candiAdc){  
            // CASE 3: Calibrate hit as usual.
            calib_charge.push_back((channel->adc(hitIdx) -adcBaseline) * adcToSpe);
          }else{  
            // CASE 4: Apply charge correction - Matt's code.
            double chg = channel->adc(hitIdx);
            if (m_useDynamicChgCorr) {
              AdPmtSensor pmtSens(sensDetId.fullPackedData());
              int pmtIdx = 24 * (pmtSens.ring() - 1) + pmtSens.column() - 1;
              
              double norm_chg = chg + (PED_NORM - m_basePed[pmtIdx]);
              double bias = m_dynChgCorr->getBias(pmtIdx, sensDetId, norm_chg,
                                                  trigTime.GetSec(),
                                                  trigTime.GetNanoSec(),
                                                  calibTime, svcMode);
              if (bias > 1){
                chg -= bias + m_basePed[pmtIdx];
              }else {
                m_basePed[pmtIdx] = adcBaseline;
                chg -=  adcBaseline;
              }
            }else {
              chg -= adcBaseline;
            }
            calib_charge.push_back(chg * adcToSpe);
          }
          
        }
        
        lastTdc = candiTdc;
        lastAdc = candiAdc;
        lastAdcBaseline = adcBaseline;
      } // Calibration of closely spaced hits
            
    }
    cro_ch.setTime(calib_time);
    cro_ch.setCharge(calib_charge);
  }
  
  return StatusCode::SUCCESS;
}
StatusCode SimpPmtCalibTool::initialize ( ) [virtual]

Definition at line 71 of file SimpPmtCalibTool.cc.

{
  // Get CalibData Service
  m_calibDataSvc = svc<IPmtCalibSvc>(m_calibDataSvcName, true);

  // Get CableData Service
  m_cableSvc = svc<ICableSvc>(m_cableSvcName, true);

  debug() << "successfully get CableSvc and CalibSvc" << endreq;

  // channel quality service
  m_chanqualSvc = svc<IChannelQualitySvc>(m_ChannelQualitySvcName,true);

  
  if (m_useDynamicChgCorr) {
    m_dynChgCorr = auto_ptr<DynChgCorrUtil>
      (new DynChgCorrUtil(this, m_calibDataSvc));
    m_basePed = new double[192];
  }

  bogusCount=0;
  nodbCount=0;
  badstatCount=0;
  nocqCount=0;

  return StatusCode::SUCCESS;
}
StatusCode SimpPmtCalibTool::finalize ( ) [virtual]

Definition at line 100 of file SimpPmtCalibTool.cc.

{
  if (m_useDynamicChgCorr) delete [] m_basePed;

  //Status report for bogus PMTs
  if(bogusCount>0){
    info() << "******* Summary report of bogus PMTs ********* " << endreq;
    std::map<DayaBay::FeeChannelId, int>::const_iterator channelIter, channelEnd=m_bogus_pmt.end();
    for(channelIter=m_bogus_pmt.begin(); channelIter!=channelEnd; ++channelIter){
      info() << "Fee Channel (detector, board, conn): " << channelIter->first.detName() << "," << channelIter->first.board() << "," << channelIter->first.connector() << " with " << channelIter->second << " calls." << endreq;
    }
  } else {
    info() << "***** No bogus PMTs were encountered" << endreq;
  }
  //Status report for PMTs with no gain calibration properties
  if(nodbCount>0){
    info() << "******* Summary report of non-bogus PMTs with no GAIN calibration properties *********" << endreq;
    std::map<DayaBay::DetectorSensor, int>::const_iterator sensIter, sensEnd=m_nodb_pmt.end();
    for(sensIter=m_nodb_pmt.begin(); sensIter!=sensEnd; ++sensIter){
      if(sensIter->first.isAD()){
        DayaBay::AdPmtSensor pmtId(sensIter->first.fullPackedData());
        info() << "AD Channel (col,ring): " << pmtId.column() << "," << pmtId.ring() << " and Id " << pmtId.asString() << " with " << sensIter->second << " calls." << endreq;
      } else if(sensIter->first.isWaterShield()){
        DayaBay::PoolPmtSensor pmtId(sensIter->first.fullPackedData());
        info() << "WP Channel (wall,spot): " << pmtId.wallNumber() << "," << pmtId.wallSpot() << " and Id " << pmtId.asString() << " with " << sensIter->second << " calls." << endreq;
      }
    }
  } else {
    info() << "***** Found no non-bogus PMTs without calibration properties in db (which is good!)" << endreq;
  }
  //Status report for PMTs with no timing calibration properties
  if(notmCount>0){
    info() << "******* Summary report of non-bogus PMTs with no TIMING calibration properties *********" << endreq;
    info() << "------ Note: omitting 2inch PMTs from this list ------------" << endl;
    std::map<DayaBay::DetectorSensor, int>::const_iterator sensIter, sensEnd=m_notm_pmt.end();
    for(sensIter=m_notm_pmt.begin(); sensIter!=sensEnd; ++sensIter){
      if(sensIter->first.isAD()){
          DayaBay::AdPmtSensor pmtId(sensIter->first.fullPackedData());
          if(pmtId.ring()>0){
            info() << "AD Channel (col,ring): " << pmtId.column() << "," << pmtId.ring() << " and Id " << pmtId.asString() << " with " << sensIter->second << " calls." << endreq;
        }
      } else if(sensIter->first.isWaterShield()){
        DayaBay::PoolPmtSensor pmtId(sensIter->first.fullPackedData());
        info() << "WP Channel (wall,spot): " << pmtId.wallNumber() << "," << pmtId.wallSpot() << " and Id " << pmtId.asString() << " with " << sensIter->second << " calls." << endreq;
      }
    }
  } else {
    info() << "***** Found no non-bogus PMTs without timing calibration properties in db (which is good!)" << endreq;
  }
  //Status report for PMTs with bad status 
  if(badstatCount>0){
    info() << "******* Summary report of non-bogus PMTs with bad status in database  *********" << endreq;
    std::map<DayaBay::DetectorSensor, int>::const_iterator sensIter, sensEnd=m_badstat_pmt.end();
    for(sensIter=m_badstat_pmt.begin(); sensIter!=sensEnd; ++sensIter){
      if(sensIter->first.isAD()){
        DayaBay::AdPmtSensor pmtId(sensIter->first.fullPackedData());
        info() << "AD Channel (col,ring): " << pmtId.column() << "," << pmtId.ring() << " and Id " << pmtId.asString() << " with " << sensIter->second << " calls." << endreq;
      } else if(sensIter->first.isWaterShield()){
        DayaBay::PoolPmtSensor pmtId(sensIter->first.fullPackedData());
        info() << "WP Channel (wall,spot): " << pmtId.wallNumber() << "," << pmtId.wallSpot() << " and Id " << pmtId.asString() << " with " << sensIter->second << " calls." << endreq;
      }
    }
  } else {
    info() << "***** Found no non-bogus PMTs with bad status in db" << endreq;
  }

  //Status report for null Channel Quality Service
  if (nocqCount > 0)
    warning() << "******* Got null Channel Quality objects for "<< nocqCount << " times  *********" << endreq;


  return StatusCode::SUCCESS;
}
const InterfaceID & ICalibTool::interfaceID ( ) [static, inherited]

Retrieve interface ID.

Definition at line 8 of file ICalibTool.cc.

{ 
    return IID_ICalibTool; 
}

Member Data Documentation

std::string SimpPmtCalibTool::m_calibDataSvcName [private]

Definition at line 50 of file SimpPmtCalibTool.h.

Definition at line 53 of file SimpPmtCalibTool.h.

std::string SimpPmtCalibTool::m_cableSvcName [private]

Definition at line 56 of file SimpPmtCalibTool.h.

Definition at line 59 of file SimpPmtCalibTool.h.

Definition at line 62 of file SimpPmtCalibTool.h.

Definition at line 65 of file SimpPmtCalibTool.h.

Definition at line 68 of file SimpPmtCalibTool.h.

Definition at line 71 of file SimpPmtCalibTool.h.

Definition at line 74 of file SimpPmtCalibTool.h.

Definition at line 78 of file SimpPmtCalibTool.h.

Definition at line 80 of file SimpPmtCalibTool.h.

Definition at line 84 of file SimpPmtCalibTool.h.

double* SimpPmtCalibTool::m_basePed [private]

Definition at line 85 of file SimpPmtCalibTool.h.

Definition at line 88 of file SimpPmtCalibTool.h.

Definition at line 89 of file SimpPmtCalibTool.h.

Definition at line 90 of file SimpPmtCalibTool.h.

Definition at line 91 of file SimpPmtCalibTool.h.

Definition at line 92 of file SimpPmtCalibTool.h.

Definition at line 93 of file SimpPmtCalibTool.h.

Definition at line 94 of file SimpPmtCalibTool.h.

Definition at line 95 of file SimpPmtCalibTool.h.

Definition at line 96 of file SimpPmtCalibTool.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 Fri May 16 2014 10:14:11 for CalibAlg by doxygen 1.7.4