/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 | Private Member Functions | Private Attributes
AdCalibFigs Class Reference

#include <AdCalibFigs.h>

Collaboration diagram for AdCalibFigs:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 AdCalibFigs (const std::string &name, ISvcLocator *pSvcLocator)
virtual ~AdCalibFigs ()
virtual StatusCode initialize ()
virtual StatusCode execute ()
virtual StatusCode finalize ()

Private Member Functions

TH1 * getOrMakeHist (int run, const DayaBay::Detector &detector, int column, int ring, int histogram, int board=0, int connector=0)
std::string getPath (int run, const char *detectorName, int column, int ring, const char *histName, int board=0, int connector=0)

Private Attributes

IStatisticsSvcm_statsSvc
ICableSvc * m_cableSvc
TimeStampm_firstTriggerTime
std::map< DayaBay::Detector,
TimeStamp
m_lastTriggerTime
std::map< int, TH1 ** > m_shortCuts
std::vector< TH1 * > m_normalize

Detailed Description

Definition at line 48 of file AdCalibFigs.h.


Constructor & Destructor Documentation

AdCalibFigs::AdCalibFigs ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 25 of file AdCalibFigs.cc.

  : GaudiAlgorithm(name,pSvcLocator),
    m_statsSvc(0),
    m_firstTriggerTime(0)
{
}
AdCalibFigs::~AdCalibFigs ( ) [virtual]

Definition at line 33 of file AdCalibFigs.cc.

{
}

Member Function Documentation

StatusCode AdCalibFigs::initialize ( ) [virtual]

Definition at line 37 of file AdCalibFigs.cc.

{
  // Initialize the necessary services
  StatusCode sc = this->service("StatisticsSvc",m_statsSvc,true);
  if(sc.isFailure()){
    error() << "Failed to get StatisticsSvc" << endreq;
    return sc;
  }

  // Initialize cable service
  sc = service("CableSvc",m_cableSvc);
  if( sc.isFailure() ) {
    error() << "Can't get CableSvc" << endreq;
    return sc;
  }

  return sc;
}
StatusCode AdCalibFigs::execute ( ) [virtual]

Definition at line 56 of file AdCalibFigs.cc.

{
  // Add the current event into histograms
  DayaBay::CalibReadoutHeader* calibHeader = 
    get<DayaBay::CalibReadoutHeader>("/Event/CalibReadout/CalibReadoutHeader");
  if(!calibHeader){
    error() << "Failed to get calibrated readout header." << endreq;
    return StatusCode::FAILURE;
  }

  DetectorId::DetectorId_t detectorId = calibHeader->context().GetDetId();
  if(!(detectorId==DetectorId::kAD1 
       || detectorId==DetectorId::kAD2 
       || detectorId==DetectorId::kAD3 
       || detectorId==DetectorId::kAD4)){
    // Not an AD, continue
    return StatusCode::SUCCESS;
  }

  // Add access to CalibStats
  if(!exist<DayaBay::UserDataHeader>("/Event/Data/CalibStats")){
    // No calibstats data this cycle
    return StatusCode::SUCCESS;
  }

  DayaBay::UserDataHeader* calibStats = 
    get<DayaBay::UserDataHeader>("/Event/Data/CalibStats");
  if(!calibStats){
    error() << "Failed to get CalibStats data" << endreq;
    return StatusCode::FAILURE;
  }

  ServiceMode svcMode( calibHeader->context(),0 );

  const DayaBay::CalibReadout* readout = calibHeader->calibReadout();
  if(!readout){
    error() << "Failed to get calibrated readout from header" << endreq;
    return StatusCode::FAILURE;
  }
  
  // Convert to PMT crate readout
  const DayaBay::CalibReadoutPmtCrate* pmtReadout
    = dynamic_cast<const DayaBay::CalibReadoutPmtCrate*>(readout);
  if(!pmtReadout){
    error() << "Failed to get PMT readout" << endreq;
    return StatusCode::FAILURE;
  }

  int runNumber = 0;

  // Add the current event into histograms
  DayaBay::ReadoutHeader* readoutHeader = 
    get<DayaBay::ReadoutHeader>("/Event/Readout/ReadoutHeader");
  if(!readoutHeader){
    error() << "Failed to get readout header." << endreq;
    return StatusCode::FAILURE;
  }
  
  const DayaBay::DaqCrate* ro = readoutHeader->daqCrate();
  if(!ro){
    error() << "Failed to get readout from header" << endreq;
    return StatusCode::FAILURE;
  }
    
  runNumber = ro->runNumber();
  
  // Convert to PMT crate readout
  const DayaBay::DaqPmtCrate* pmtCrate
      = ro->asPmtCrate();
  if(!pmtCrate){
    // Not an AD, continue
    return StatusCode::SUCCESS;
  }

  //get the trigger type of this trigger
  unsigned int trigType = pmtCrate->triggerType();
  const int mask = 0x0fffffff; //remove leading 1 
  
  //a stupid way to identify self trigger events
  int man = mask & (trigType & DayaBay::Trigger::kManual);
  int xs = mask & (trigType & DayaBay::Trigger::kCross);
  int peri = mask & (trigType & DayaBay::Trigger::kPeriodic);
  int ped = mask & (trigType & DayaBay::Trigger::kPedestal);
  int cal = mask & (trigType & DayaBay::Trigger::kCalib);
  int ran = mask & (trigType & DayaBay::Trigger::kRandom);
  int unk = mask & (trigType & DayaBay::Trigger::kUnknown);
  
  //printf("trig %x, man %x, xs %x, peri %x, ped %x, cal %x, ran %x, unk %x\n",
  //trigType, man, xs, peri, ped, cal, ran, unk);
  
  int selftrig = 0;
  if((!man)&&(!xs)&&(!peri)&&(!ped)&&(!cal)&&(!ran)&&(!unk)) selftrig = 1;

  if(!m_firstTriggerTime){
    m_firstTriggerTime = new TimeStamp(readout->triggerTime());
  }

  // Find histograms
  const DayaBay::Detector& detector = readout->detector();
  TH1F* adCharge = dynamic_cast<TH1F*>(this->getOrMakeHist(runNumber,
                                                           detector,
                                                           0, 0, ADCHARGE));
  TH1F* logAdCharge = dynamic_cast<TH1F*>(this->getOrMakeHist(runNumber,
                                                              detector,
                                                              0, 0, 
                                                              LOGADCHARGE));
  TH2F* pmtCharge = dynamic_cast<TH2F*>(this->getOrMakeHist(runNumber,
                                                            detector,
                                                            0, 0, 
                                                            PMTCHARGE));
  TH2F* adChargeVsTime =  dynamic_cast<TH2F*>(this->getOrMakeHist(runNumber,
                                                               detector,
                                                               0, 0, 
                                                               ADCHARGEVSTIME));
  TH2F* adChargeVsDtTrigger =  dynamic_cast<TH2F*>(this->getOrMakeHist(
                                                         runNumber,
                                                         detector,
                                                         0, 0, 
                                                         ADCHARGEVSDTTRIGGER));
  TH2F* maxPmtChargeVsAdCharge =  dynamic_cast<TH2F*>(this->getOrMakeHist(
                                                      runNumber,
                                                      detector,
                                                      0, 0, 
                                                      MAXPMTCHARGEVSADCHARGE));
  TH2F* nChannelsVsAdCharge = dynamic_cast<TH2F*>(this->getOrMakeHist(
                                                 runNumber,
                                                 detector,
                                                 0, 0, 
                                                 NCHANNELSVSADCHARGE));

  TH2F* ratioQmaxQtotVsTrms = dynamic_cast<TH2F*>(this->getOrMakeHist(
                                                 runNumber,
                                                 detector,
                                                 0, 0,
                                                 RATIOQMAXQTOTVSTRMS));
  TH1F* logFlasherEllipse = dynamic_cast<TH1F*>(this->getOrMakeHist(runNumber,
                                                                    detector,
                                                                    0, 0, 
                                                                    LOGFLASHERELLIPSE));
//  TH2F* maxQ8VsMaxQ2 = dynamic_cast<TH2F*>(this->getOrMakeHist(
//                                               runNumber,
//                                               detector,
//                                               0, 0,
//                                               MAXQ8VSMAXQ2));
//                                                
  // fill ellipse variable from CalibStats
  float maxQ = calibStats->getFloat("MaxQ"); 
  float quadrant = calibStats->getFloat("Quadrant"); 
  float ellipse = quadrant*quadrant + (maxQ/0.45)*(maxQ/0.45);
  logFlasherEllipse->Fill( TMath::Log10(ellipse) );

  //float maxQ_2inch = calibStats->getFloat("MaxQ_2inchPMT");
  //float nominalCharge = calibStats->getFloat("NominalCharge");

  while(readout->triggerTime().GetSeconds() >= 
        adChargeVsTime->GetXaxis()->GetXmax()){
    StatusCode sc = HistogramTools::extendRange(msgSvc(), adChargeVsTime, 60);
    if(!sc.isSuccess()) return sc;
  }
                                                  
  const DayaBay::CalibReadoutPmtCrate::PmtChannelReadouts& channels
    = pmtReadout->channelReadout();
  
  DayaBay::CalibReadoutPmtCrate::PmtChannelReadouts::const_iterator channelIter,
    channelEnd = channels.end();
  
  double adSumCharge = 0;
  double maxPmtCharge = 0;
  double maxCalibPmtCharge = 0;
  double tRMS = 0;
  int max_pmtidpacked(0);
  int max_calibpmtidpacked(0);
  int nHits(0);

  TH1F *hhittime = new TH1F("hhittime","hit time", 200, -2000, 0);
  nHits = channels.size();
  
  for(channelIter = channels.begin(); channelIter!=channelEnd; channelIter++) { 
    const DayaBay::CalibReadoutPmtChannel& channel = *channelIter;

    DayaBay::AdPmtSensor pmtId( channel.pmtSensorId().fullPackedData() );
    int column = pmtId.column();
    int ring = pmtId.ring();

    // Channel Hit Map
    double charge = channel.maxCharge();
    pmtCharge->Fill(column, ring, charge);
    adSumCharge += charge;

    if( ring==0 && charge>maxCalibPmtCharge){
      //max 2 inch PMT
      maxCalibPmtCharge = charge;
      max_calibpmtidpacked = channel.pmtSensorId().fullPackedData();
    }

    if( ring>0 && charge > maxPmtCharge ) {
      //max 8 inch PMT
      maxPmtCharge = charge;
      //get the max charge channel!
      max_pmtidpacked = channel.pmtSensorId().fullPackedData();
    }

    for(size_t ii=0;ii<channel.size();ii++){
      if(channel.time(ii)>-1650&&channel.time(ii)<-1350){
        hhittime->Fill(channel.time(ii));
        break;
      }
    }
  }
  //now get RMS time for this event
  tRMS = hhittime->GetRMS();
  
  delete hhittime; hhittime=0;

  if(m_lastTriggerTime.find(readout->detector()) != m_lastTriggerTime.end()){
    TimeStamp dtTriggerTime = readout->triggerTime();
    dtTriggerTime.Subtract(m_lastTriggerTime[readout->detector()]);
    if(adSumCharge>0){
      adChargeVsDtTrigger->Fill(dtTriggerTime.GetSeconds()*1e6,
                                TMath::Log10( adSumCharge ) );
    }
  }

  adCharge->Fill( adSumCharge );
  if(adSumCharge>0){
    double logAdSumCharge = TMath::Log10( adSumCharge );
    logAdCharge->Fill( logAdSumCharge );
    if(adChargeVsTime->GetYaxis()->GetXmin()<=logAdSumCharge
       && adChargeVsTime->GetYaxis()->GetXmax()>logAdSumCharge){
      adChargeVsTime->Fill(readout->triggerTime().GetSeconds(), logAdSumCharge );
    }
    maxPmtChargeVsAdCharge->Fill(logAdSumCharge, maxPmtCharge/adSumCharge);
    nChannelsVsAdCharge->Fill(logAdSumCharge, channels.size());

    //now fill the flasher identification histogram: qmax/qtot vs trms
    if(selftrig && adSumCharge>800) {//require energy of flasher be neutron-like and above
      ratioQmaxQtotVsTrms->Fill(tRMS, maxPmtCharge/adSumCharge);
    }

//    maxQ8VsMaxQ2->Fill(maxCalibPmtCharge, TMath::Log10(maxPmtCharge));
    if(maxCalibPmtCharge>50 && maxCalibPmtCharge>maxPmtCharge){
      //2inch flasher
      DayaBay::AdPmtSensor pmtId( max_calibpmtidpacked );
      DayaBay::FeeChannelId feechan = m_cableSvc->feeChannelId(pmtId, svcMode);
      int ring = pmtId.ring();
      int column = pmtId.column();
      int board = feechan.board();
      int connector = feechan.connector();
      //printf("2inch flasher: board %d connector %d maxQ_2inch %f maxCalibCharge %f max8inchCharge %f nominalCharge %f\n",
      //       board, connector, maxQ_2inch, maxCalibPmtCharge, maxPmtCharge, nominalCharge);

      TH1F* hFlasherCharge 
        =  dynamic_cast<TH1F*>(this->getOrMakeHist(
                                             runNumber,
                                             detector,
                                             column, ring, 
                                             QFLASHERPMT, board, connector));   
      hFlasherCharge->Fill(maxCalibPmtCharge);
    
    }
    
    else if(ellipse>1){
      //8 inch flasher
      DayaBay::AdPmtSensor pmtId( max_pmtidpacked );
      DayaBay::FeeChannelId feechan = m_cableSvc->feeChannelId(pmtId, svcMode);
      int ring = pmtId.ring();
      int column = pmtId.column();
      int board = feechan.board();
      int connector = feechan.connector();
      if(ring>0){
        //printf("ellipse 8 inch: det %d ellipse %f column %d max8incharge %f max2incharge%f nominalCharge%f\n",
        //       int(detector.detectorId()), ellipse, pmtId.column(), maxPmtCharge, maxCalibPmtCharge, nominalCharge);
        //fill histogram for the max channel. 1 means use board/connector
        //to sort histograms
        TH1F* hFlasherCharge 
          =  dynamic_cast<TH1F*>(this->getOrMakeHist(
                                                     runNumber,
                                                     detector,
                                                     column, ring, 
                                                     QFLASHERPMT, board, connector));   
        hFlasherCharge->Fill(maxPmtCharge);
        //printf("trig\t%x\tnhit\t%d\tqmax\t%.2f\tqtot\t%.2f\ttrms%.2f\tboard\t%d\tconnector\t%d\n",trigType,nHits,maxPmtCharge,adSumCharge,tRMS,board,connector);  
      }
    }
    
  }

  pmtCharge->SetNormFactor( pmtCharge->GetNormFactor()+1 );
  m_lastTriggerTime[readout->detector()] = readout->triggerTime();

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

Definition at line 349 of file AdCalibFigs.cc.

{
  // Handle Normalized histograms
  for(unsigned int normIdx=0; normIdx<m_normalize.size(); normIdx++){
    TH1* hist = m_normalize[normIdx];
    hist->Sumw2();
    if(hist->GetNormFactor()>0){
      double scale = 1./hist->GetNormFactor();
      hist->SetNormFactor(1);
      hist->Scale( scale );
    }
    hist->SetBit(TH1::kIsAverage);
  }
  m_normalize.clear();
  // Clean-up histogram shortcuts
  std::map<int,TH1**>::iterator histIter, histEnd = m_shortCuts.end();
  for(histIter = m_shortCuts.begin(); histIter!=histEnd; histIter++){
    delete [] (histIter->second);
    histIter->second = 0;
  }
  if( m_statsSvc ) m_statsSvc->release();
  if(m_firstTriggerTime){
    delete m_firstTriggerTime;
    m_firstTriggerTime = 0;
  }
  return StatusCode::SUCCESS;
}
TH1 * AdCalibFigs::getOrMakeHist ( int  run,
const DayaBay::Detector detector,
int  column,
int  ring,
int  histogram,
int  board = 0,
int  connector = 0 
) [private]

Definition at line 379 of file AdCalibFigs.cc.

{
  int siteInt = 0;
  switch(detector.site()){
  case Site::kUnknown:
    siteInt = 0; break;
  case Site::kDayaBay:
    siteInt = 1; break;
  case Site::kLingAo:
    siteInt = 2; break;
  case Site::kFar:
    siteInt = 3; break;
  case Site::kSAB:
    siteInt = 4; break;
  default:
    error() << "Unknown site: " << detector.detName() << endreq;
    return 0;
  }
  int detectorInt = int(detector.detectorId());
  std::map<int,TH1**>::iterator histIter = m_shortCuts.find(run);
  TH1** histograms = 0;
  if( histIter == m_shortCuts.end() ){
    // Initialize histogram shortcuts
    histograms = new TH1*[MAXCALIBHISTS];
    for(int i=0; i<MAXCALIBHISTS; i++) histograms[i] = 0;
    m_shortCuts[run] = histograms;
  }else{
    // Found run
    histograms = histIter->second;
  }

  TH1* hist = 
    histograms[siteInt * NDETECTORS * NCOLUMNS * NRINGS * NCALIBHISTOGRAMS
               + detectorInt * NCOLUMNS * NRINGS * NCALIBHISTOGRAMS
               + column * NRINGS * NCALIBHISTOGRAMS
               + ring * NCALIBHISTOGRAMS
               + histogram];

  if(!hist){
    // Make this histogram
    std::string histName;
    if(detector.detectorId()){
      // Make detector histogram
      switch(histogram){
      case ADCHARGE:
        // AD Calibrated Charge
        histName = "adCharge";
        hist = new TH1F(histName.c_str(),"AD Calibrated Charge",
                        1100,-200,2000);
        hist->GetXaxis()->SetTitle("Photoelectrons");
        hist->GetYaxis()->SetTitle("Events");
        break;
      case LOGADCHARGE:
        // Log of AD Calibrated Charge
        histName = "logAdCharge";
        hist = new TH1F(histName.c_str(),"AD Calibrated Charge",
                        800,-1,7);
        hist->GetXaxis()->SetTitle("log_{10}( Photoelectrons )");
        hist->GetYaxis()->SetTitle("Events");
        break;
      case PMTCHARGE:
        // Sum of PMT charge
        histName = "pmtCharge";
        hist = new TH2F(histName.c_str(),"Mean PMT Charge by Column/Ring",
                        49,0.25,24.75,19,-0.75,8.75);
        hist->GetXaxis()->SetTitle("PMT Column");
        hist->GetYaxis()->SetTitle("PMT Ring");
        hist->SetStats(0);
        m_normalize.push_back(hist);
        hist->SetNormFactor(0);
        break;
      case ADCHARGEVSTIME:
        // AD Charge vs. time
        histName = "adChargeVsTime";
        hist = new TH2F(histName.c_str(),
                        "AD Charge vs. Time",
                        60,m_firstTriggerTime->GetSec(),
                        m_firstTriggerTime->GetSec()+60,
                        200,-1,7);
        hist->GetXaxis()->SetTitle("Run Time [Beijing]");
        hist->GetYaxis()->SetTitle("log_{10}( Photoelectrons )");
        hist->GetXaxis()->SetTimeDisplay(1);
        hist->GetXaxis()->SetTimeFormat(timeFormat_AdCalibFigs);
        hist->GetXaxis()->SetTimeOffset(0,"gmt");
        hist->GetXaxis()->SetNdivisions(505);
        break;
      case ADCHARGEVSDTTRIGGER:
        // AD Charge vs DT trigger
        histName = "adChargeVsDtTrigger";
        hist = new TH2F(histName.c_str(),"AD Charge vs time to last event",
                        200,0,100,200,-1,7);
        hist->GetXaxis()->SetTitle("#DeltaT [us]");
        hist->GetYaxis()->SetTitle("log_{10}( Photoelectrons )");
        break;
      case MAXPMTCHARGEVSADCHARGE:
        // Max PMT Charge vs. AD Charge
        histName = "maxPmtChargeVsAdCharge";
        hist = new TH2F(histName.c_str(),"Fraction of Charge in one PMT",
                        200,-1,7,110,0,1.1);
        hist->GetXaxis()->SetTitle("log_{10}( Photoelectrons )");
        hist->GetYaxis()->SetTitle("PMT / Total");
        break;
      case NCHANNELSVSADCHARGE:
        // Number of Hit Channels vs. AD Charge
        histName = "nChannelsVsAdCharge";
        hist = new TH2F(histName.c_str(),
                        "Number of hit channels vs. Total AD Charge",
                        200,-1,7,200,0,200);
        hist->GetXaxis()->SetTitle("log_{10}( Photoelectrons )");
        hist->GetYaxis()->SetTitle("Hit Channels");
        break;
      case RATIOQMAXQTOTVSTRMS:
        // Qmax/Qtot vs Trms
        histName = "ratioQmaxQtotVsTrms";
        hist = new TH2F(histName.c_str(),"Qmax/Qtot vs Trms",
                        1200, 0, 1200, 100, 0, 1);
        hist->GetXaxis()->SetTitle("Trms (ns)");
        hist->GetYaxis()->SetTitle("Qmax/Qtot");
        break;
      case QFLASHERPMT:
        // charge of the flashing PMT
        histName = "qFlasherPMT";
        hist = new TH1F(histName.c_str(),"charge of the flashing PMT",
                        300, 0, 3000);
        hist->GetXaxis()->SetTitle("charge (PE)");
        hist->GetYaxis()->SetTitle("Events/10PE");
        break;
      case LOGFLASHERELLIPSE:
        // flasher variable ellipse 
        histName = "logFlasherEllipse";
        hist = new TH1F(histName.c_str(),"Flasher ID Variable Ellipse",
                        200,-2,2);
        hist->GetXaxis()->SetTitle("log_{10}( Ellipse )");
        hist->GetYaxis()->SetTitle("Events");
        break;
//      case MAXQ8VSMAXQ2:
//      // Qmax/Qtot vs Trms
//      histName = "maxQ8VsMaxQ2";
//      hist = new TH2F(histName.c_str(),"maxQ 8inch Vs maxQ 2inch",
//                      1500, 0, 1500, 8, -3, 5);
//      hist->GetXaxis()->SetTitle("maxQ 2inch");
//      hist->GetYaxis()->SetTitle("maxQ 8inch");
//      break;
      default:
        error() << "Unknown Histogram: " << histogram << endreq;
        return 0;
      }
    }

    debug() << "Making histogram: " << histName << endreq;
    m_statsSvc->put( this->getPath(run, detector.detName().c_str(), column, 
                                   ring, histName.c_str(), board, connector), 
                     hist );
    histograms[siteInt * NDETECTORS * NCOLUMNS * NRINGS * NCALIBHISTOGRAMS
               + detectorInt * NCOLUMNS * NRINGS * NCALIBHISTOGRAMS
               + column * NRINGS * NCALIBHISTOGRAMS
               + ring * NCALIBHISTOGRAMS
               + histogram] = hist;
  }

  return hist;
}
std::string AdCalibFigs::getPath ( int  run,
const char *  detectorName,
int  column,
int  ring,
const char *  histName,
int  board = 0,
int  connector = 0 
) [private]

Definition at line 544 of file AdCalibFigs.cc.

{
  // Construct histogram path in statistics service
  std::stringstream path;
  path << "/file1/diagnostics/run_" << std::setfill('0') << std::setw(7) 
       << run;
  if(detectorName){
    path << "/detector_" << detectorName;

    if(column){
      if(board){
      // hack to save pmt hist in board/connector folder instead of ring/column folder
        path << "/channel_board" << std::setfill('0') << std::setw(2) 
             << board << "_connector" << std::setfill('0') << std::setw(2)
             << connector;
      } else {
        path << "/channel_column" << std::setfill('0') << std::setw(2) 
             << column << "_ring" << std::setfill('0') << std::setw(2)
             << ring;
      }
    }
  }
  path << "/" << histName;
  return path.str();
}

Member Data Documentation

Definition at line 69 of file AdCalibFigs.h.

ICableSvc* AdCalibFigs::m_cableSvc [private]

Definition at line 70 of file AdCalibFigs.h.

Definition at line 72 of file AdCalibFigs.h.

Definition at line 73 of file AdCalibFigs.h.

std::map<int,TH1**> AdCalibFigs::m_shortCuts [private]

Definition at line 74 of file AdCalibFigs.h.

std::vector<TH1*> AdCalibFigs::m_normalize [private]

Definition at line 75 of file AdCalibFigs.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:04:10 for AdBasicFigs by doxygen 1.7.4