/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
MuonCalibFigs Class Reference

#include <MuonCalibFigs.h>

Collaboration diagram for MuonCalibFigs:
Collaboration graph
[legend]

List of all members.

Public Member Functions

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

Private Member Functions

TH1 * getOrMakeHist (int run, const DayaBay::Detector &detector, int histogram)
std::string getPath (int run, const char *detectorName, const char *histName)
XYPos getPmtHistXY (DayaBay::PoolPmtSensor pmtId)

Private Attributes

IPmtGeomInfoSvcm_pmtGeomSvc
IStatisticsSvcm_statsSvc
IDaqDetailsSvc * m_daqDetailsSvc
TimeStampm_firstTriggerTime
std::map< DayaBay::Detector,
TimeStamp
m_lastTriggerTime
std::map< int, TH1 ** > m_shortCuts
std::vector< TH1 * > m_normalize
int bogusCount

Detailed Description

Definition at line 54 of file MuonCalibFigs.h.


Constructor & Destructor Documentation

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

Definition at line 32 of file MuonCalibFigs.cc.

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

Definition at line 42 of file MuonCalibFigs.cc.

{
}

Member Function Documentation

StatusCode MuonCalibFigs::initialize ( ) [virtual]

Definition at line 46 of file MuonCalibFigs.cc.

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

  sc = this->service("StatisticsSvc",m_statsSvc,true);
  if(sc.isFailure()){
    error() << "Failed to get StatisticsSvc" << endreq;
    return sc;
  }
  
  sc = this->service("DetailsFromRecordSvc", m_daqDetailsSvc, true);
  if (sc.isFailure()) {
    error() << "Failed to get IDaqDetailsSvc" << endreq;
    return sc;
  }

  bogusCount = 0;

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

Definition at line 72 of file MuonCalibFigs.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::kIWS 
       || detectorId==DetectorId::kOWS)){ 
    // Not the Water Pool, continue
    return StatusCode::SUCCESS;
  }

  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;
  }

  // Get calibstatstsHdr

  DayaBay::UserDataHeader *calibStatsHdr = 0;

  if (!exist<DayaBay::UserDataHeader>(evtSvc(), "/Event/Data/CalibStats")) {
    warning() << "Cannot find header at /Event/Data/CalibStats" << endreq;
    return StatusCode::FAILURE;
  } else {
    calibStatsHdr = get<DayaBay::UserDataHeader>("/Event/Data/CalibStats");
  }

 
  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();
  }

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

  // get trigger type
  
  const DayaBay::CalibReadout* calibReadout = calibHeader->calibReadout();
  
  if(!calibReadout) {
    warning() << "Failed to get CalibReadout from header" << endreq;
    return StatusCode::FAILURE;
  }

  int triggerType = calibReadout->triggerType();
  debug() << "trigger type : " << DayaBay::Trigger::AsString(calibReadout->triggerType()) << endreq;
  
  unsigned int mask = 0x0fffffff;
  
  int isCross = mask & triggerType & DayaBay::Trigger::kCross;
  int isMult = mask & triggerType & DayaBay::Trigger::kMult;


  // get only physics run
  // adding physics run service information here

  bool isPhysicsRun = false;
  bool isADCalibRun = false;

  ServiceMode svcMode = ServiceMode(dynamic_cast<const DayaBay::HeaderObject*>(calibHeader)->context(),0);
  
  const DaqFileDetails& fileDetails = m_daqDetailsSvc->fileDetails(svcMode);
  if (&fileDetails) {
    std::string fileName = fileDetails.fileName();
    
    size_t found  = fileName.find("Physics");
    if (found!=std::string::npos) {
      isPhysicsRun = true;
    }

    found = fileName.find("ADCalib");
    if (found!=std::string::npos) {
      isADCalibRun = true;
    }
  }

  // Find histograms
  const DayaBay::Detector& detector = readout->detector();
  TH1F* muonCharge = dynamic_cast<TH1F*>(this->getOrMakeHist(runNumber,
                                                          detector,
                                                          MUONCHARGE));
  TH1F* logMuonCharge = dynamic_cast<TH1F*>(this->getOrMakeHist(runNumber,
                                                          detector,
                                                          LOGMUONCHARGE));
  TH2F* muonPmtCharge = dynamic_cast<TH2F*>(this->getOrMakeHist(runNumber,
                                                          detector,
                                                          MUONPMTCHARGE));
  TH2F* muonChargeVsTime =  dynamic_cast<TH2F*>(this->getOrMakeHist(runNumber,
                                                          detector,
                                                          MUONCHARGEVSTIME));
  TH2F* muonChargeVsDtTrigger =  dynamic_cast<TH2F*>(this->getOrMakeHist(
                                                      runNumber,
                                                      detector,
                                                      MUONCHARGEVSDTTRIGGER));
  TH2F* maxPmtChargeVsMuonCharge =  dynamic_cast<TH2F*>(this->getOrMakeHist(
                                                  runNumber,
                                                  detector,
                                                  MAXPMTCHARGEVSMUONCHARGE));
  TH2F* nChannelsVsMuonCharge = dynamic_cast<TH2F*>(this->getOrMakeHist(
                                                 runNumber,
                                                 detector,
                                                 NCHANNELSVSMUONCHARGE));

  TH1F* muonPmtNhitID = dynamic_cast<TH1F*>(this->getOrMakeHist(
                                                                runNumber,
                                                                detector,
                                                                MUONPMTNHITID));
  TH1F* muonPmtEsumID = dynamic_cast<TH1F*>(this->getOrMakeHist(
                                                                runNumber,
                                                                detector,
                                                                MUONPMTPESUMID));
    
  TH2F* muonPmtNhitVsTime = dynamic_cast<TH2F*>(this->getOrMakeHist(runNumber,
                                                                    detector,
                                                                    MUONPMTNHIT));

  TH2F* muonPmtEsumVsTime = dynamic_cast<TH2F*>(this->getOrMakeHist(runNumber,
                                                                    detector,
                                                                    MUONPMTPESUM));
  while(readout->triggerTime().GetSeconds() >= 
        muonChargeVsTime->GetXaxis()->GetXmax()){
    StatusCode sc = HistogramTools::extendRange(msgSvc(), muonChargeVsTime, 60);
    if(!sc.isSuccess()) return sc;
  }


  while (readout->triggerTime().GetSeconds() >=
         muonPmtNhitVsTime->GetXaxis()->GetXmax()) {
    StatusCode sc = HistogramTools::extendRange(msgSvc(), muonPmtNhitVsTime, 60);
    if(!sc.isSuccess()) return sc;
  }
  
  while (readout->triggerTime().GetSeconds() >=
         muonPmtEsumVsTime->GetXaxis()->GetXmax()) {
    StatusCode sc = HistogramTools::extendRange(msgSvc(), muonPmtEsumVsTime, 60);
    if(!sc.isSuccess()) return sc;
  }
 
  double muonPmtEsum = calibStatsHdr->getFloat("NominalCharge");
  int muonPmtNhit = calibStatsHdr->getInt("nHit");

  if (isPhysicsRun || isADCalibRun) {
    if (isMult>0 && isCross==0) {
      if (muonPmtNhit>30) {
        muonPmtNhitID->Fill(muonPmtNhit);
        muonPmtEsumID->Fill(muonPmtEsum);
        
        if(muonPmtNhitVsTime->GetYaxis()->GetXmin()<= muonPmtNhit
           && muonPmtNhitVsTime->GetYaxis()->GetXmax()>muonPmtNhit){
          muonPmtNhitVsTime->Fill(readout->triggerTime().GetSeconds(), muonPmtNhit);
        }

        if (muonPmtEsumVsTime->GetYaxis()->GetXmin()<= muonPmtEsum
            && muonPmtEsumVsTime->GetYaxis()->GetXmax()>muonPmtEsum) {
          muonPmtEsumVsTime->Fill(readout->triggerTime().GetSeconds(), muonPmtEsum);
        }
      }
    }
  }

  const DayaBay::CalibReadoutPmtCrate::PmtChannelReadouts& channels
    = pmtReadout->channelReadout();
    
  DayaBay::CalibReadoutPmtCrate::PmtChannelReadouts::const_iterator channelIter,
    channelEnd = channels.end();

  double muonSumCharge = 0;
  double maxPmtCharge = 0;
  for(channelIter = channels.begin(); channelIter!=channelEnd; channelIter++) { 
    const DayaBay::CalibReadoutPmtChannel& channel = *channelIter;

    DayaBay::PoolPmtSensor pmtId( channel.pmtSensorId().fullPackedData() );
    XYPos pmtHistXY = this->getPmtHistXY( pmtId );

    // Channel Hit Map
    double charge = channel.sumCharge();
    muonPmtCharge->Fill(pmtHistXY.x, pmtHistXY.y, charge);
    muonSumCharge += charge;
    if( charge > maxPmtCharge ) maxPmtCharge = charge;
  }

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

  muonCharge->Fill( muonSumCharge );
  if(muonSumCharge>0){
    double logMuonSumCharge = TMath::Log10( muonSumCharge );
    logMuonCharge->Fill( logMuonSumCharge );
    if(muonChargeVsTime->GetYaxis()->GetXmin()<=logMuonSumCharge
       && muonChargeVsTime->GetYaxis()->GetXmax()>logMuonSumCharge){
      muonChargeVsTime->Fill(readout->triggerTime().GetSeconds(), logMuonSumCharge );
    }
    maxPmtChargeVsMuonCharge->Fill(logMuonSumCharge, maxPmtCharge/muonSumCharge);
    nChannelsVsMuonCharge->Fill(logMuonSumCharge, channels.size());
  }

  muonPmtCharge->SetNormFactor( muonPmtCharge->GetNormFactor()+1 );

  m_lastTriggerTime[readout->detector()] = readout->triggerTime();


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

Definition at line 313 of file MuonCalibFigs.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 * MuonCalibFigs::getOrMakeHist ( int  run,
const DayaBay::Detector detector,
int  histogram 
) [private]

Definition at line 343 of file MuonCalibFigs.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 * NCALIBHISTOGRAMS
               + detectorInt * NCALIBHISTOGRAMS
               + histogram];
  if(!hist){
    // Make this histogram
    std::string histName;
    if(detector.detectorId()){
      // Make detector histogram
      switch(histogram){
      case MUONCHARGE:
        // Muon Calibrated Charge
        histName = "MuonCharge";
        hist = new TH1F(histName.c_str(),"Muon Calibrated Charge",
                        1100,-100,1000);
        hist->GetXaxis()->SetTitle("Photoelectrons");
        hist->GetYaxis()->SetTitle("Events");
        break;
      case LOGMUONCHARGE:
        // Log of Muon Calibrated Charge
        histName = "logMuonCharge";
        hist = new TH1F(histName.c_str(),"Muon Calibrated Charge",
                        800,-1,7);
        hist->GetXaxis()->SetTitle("log_{10}( Photoelectrons )");
        hist->GetYaxis()->SetTitle("Events");
        break;
      case MUONPMTCHARGE:
        // Sum of PMT charge
        histName = "muonPmtCharge";
        hist = new TH2F(histName.c_str(),"Mean PMT Charge for Pool",
                        101,-20,20,100,-20,20);
        hist->GetXaxis()->SetTitle("");
        hist->GetYaxis()->SetTitle("");
        hist->SetStats(0);
        m_normalize.push_back(hist);
        hist->SetNormFactor(0);
        break;
      case MUONCHARGEVSTIME:
        // Muon Charge vs. time
        histName = "muonChargeVsTime";
        hist = new TH2F(histName.c_str(),
                        "Muon 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_MuonCalibFigs);
        hist->GetXaxis()->SetTimeOffset(0,"gmt");
        hist->GetXaxis()->SetNdivisions(505);
        break;
      case MUONCHARGEVSDTTRIGGER:
        // Muon Charge vs DT trigger
        histName = "muonChargeVsDtTrigger";
        hist = new TH2F(histName.c_str(),"Muon 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 MAXPMTCHARGEVSMUONCHARGE:
        // Max PMT Charge vs. Muon Charge
        histName = "maxPmtChargeVsMuonCharge";
        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 NCHANNELSVSMUONCHARGE:
        // Number of Hit Channels vs. Muon Charge
        histName = "nChannelsVsMuonCharge";
        hist = new TH2F(histName.c_str(),
                        "Number of hit channels vs. Total Muon Charge",
                        200,-1,7,200,0,200);
        hist->GetXaxis()->SetTitle("log_{10}( Photoelectrons )");
        hist->GetYaxis()->SetTitle("Hit Channels");
        break;
      case MUONPMTNHITID:
        // Number of Hit Channels with Muon selection Cuts
        histName = "muonPmtNhit";
        hist = new TH1F(histName.c_str(),
                        "Number of hit channles (Muon Selection)",
                        400, 0, 400);
        hist->GetXaxis()->SetTitle("nChannels");
        hist->GetYaxis()->SetTitle("Entries");
        break;
      case MUONPMTPESUMID:
        // Number of PMT charge
        histName = "muonPmtPESum";
        hist = new TH1F(histName.c_str(),
                        "Number of Sum photoelectrons (Muon Selection)",
                        1000, 0, 8000);
        hist->GetXaxis()->SetTitle("Photoelectrons");
        hist->GetYaxis()->SetTitle("Entries");
        break;

      case MUONPMTNHIT:
        // Number of Hit Channels Average .vs. Time with Muon selection Cuts
        histName = "muonPmtNhitVsTime";
        hist = new TH2F(histName.c_str(),
                        "Number of hit channles vs time (Muon Selection)",
                        60,m_firstTriggerTime->GetSec(),
                        m_firstTriggerTime->GetSec()+60,
                        400, 0, 400);
        hist->GetXaxis()->SetTitle("Run Time [Beijing]");
        hist->GetYaxis()->SetTitle("nChannels");
        hist->GetXaxis()->SetTimeDisplay(1);
        hist->GetXaxis()->SetTimeFormat(timeFormat_MuonCalibFigs);
        hist->GetXaxis()->SetTimeOffset(0,"gmt");
        hist->GetXaxis()->SetNdivisions(505);
        break;
      case MUONPMTPESUM:
        // Number of PMT charge vs Time with Muon selection cuts
        histName = "muonPMTEsumVsTime";
        hist = new TH2F(histName.c_str(),
                        "ChargeSum vs time (Muon Selection)",
                        60,m_firstTriggerTime->GetSec(),
                        m_firstTriggerTime->GetSec()+60,
                        1000, 0, 8000);
        hist->GetXaxis()->SetTitle("Run Time [Beijing]");
        hist->GetYaxis()->SetTitle("PhotoElectrons");
        hist->GetXaxis()->SetTimeDisplay(1);
        hist->GetXaxis()->SetTimeFormat(timeFormat_MuonCalibFigs);
        hist->GetXaxis()->SetTimeOffset(0,"gmt");
        hist->GetXaxis()->SetNdivisions(505);
        break;
      default:
        error() << "Unknown Histogram: " << histogram << endreq;
        return 0;
      }
    }

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

  return hist;
}
std::string MuonCalibFigs::getPath ( int  run,
const char *  detectorName,
const char *  histName 
) [private]

Definition at line 520 of file MuonCalibFigs.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;
  }
  path << "/" << histName;
  return path.str();
}
XYPos MuonCalibFigs::getPmtHistXY ( DayaBay::PoolPmtSensor  pmtId) [private]

Definition at line 534 of file MuonCalibFigs.cc.

{
  // Return an x,y position for this PMT in your favorite projection
  // of the water pool 
  XYPos pmtHistXY;
  pmtHistXY.x = 0.;
  pmtHistXY.y = 0.;

  // First, check if it is inner or outer water pool
  bool isInnerPool = false;
  if( pmtId.detectorId() == DetectorId::kIWS ){
    isInnerPool = true;
  }
  
  // If you want to map PMTs by (wallNumber, wallSpot, inwardFacing) use:
  int wallNumber = pmtId.wallNumber();
  // int wallSpot = pmtId.wallSpot();
  // bool inwardFacing = pmtId.inwardFacing();
  
  // If you want to map PMTs by x,y,z coordinate position, use:
  IPmtGeomInfo* pmtGeom = m_pmtGeomSvc->get(pmtId.fullPackedData());
  if(!pmtGeom){
    bogusCount++;

    if (bogusCount<=15) {
      warning() << "Unable to find geometry info for pmt " << pmtId << endreq;
    }

    // Put outside histogram range
    pmtHistXY.x=-30*Gaudi::Units::meter;
    pmtHistXY.y=-30*Gaudi::Units::meter;
    return pmtHistXY;
  }
  const CLHEP::Hep3Vector& pmtPos = pmtGeom->localPosition();
  double pmtPoolX = pmtPos.x();
  double pmtPoolY = pmtPos.y();
  double pmtPoolZ = pmtPos.z();

  // Do your work here
  pmtHistXY.x = pmtPoolX;
  pmtHistXY.y = pmtPoolY;
  // Unfold walls
  static double sqrt2 = sqrt(2.);
  double pmtPoolZ_floor = pmtPoolZ + 5*Gaudi::Units::meter;
  if(wallNumber==1){
    pmtHistXY.x += pmtPoolZ_floor;
  }else if(wallNumber==2){
    pmtHistXY.x += pmtPoolZ_floor/sqrt2;
    pmtHistXY.y += pmtPoolZ_floor/sqrt2;
  }else if(wallNumber==3){
    pmtHistXY.y += pmtPoolZ_floor;
  }else if(wallNumber==4){
    pmtHistXY.x -= pmtPoolZ_floor/sqrt2;
    pmtHistXY.y += pmtPoolZ_floor/sqrt2;
  }else if(wallNumber==5){
    pmtHistXY.x -= pmtPoolZ_floor;
  }else if(wallNumber==6){
    pmtHistXY.x -= pmtPoolZ_floor/sqrt2;
    pmtHistXY.y -= pmtPoolZ_floor/sqrt2;
  }else if(wallNumber==7){
    pmtHistXY.y -= pmtPoolZ_floor;
  }else if(wallNumber==8){
    pmtHistXY.x += pmtPoolZ_floor/sqrt2;
    pmtHistXY.y -= pmtPoolZ_floor/sqrt2;
  }

  // Set units
  pmtHistXY.x /= Gaudi::Units::meter; 
  pmtHistXY.y /= Gaudi::Units::meter; 

  return pmtHistXY;
}

Member Data Documentation

Definition at line 73 of file MuonCalibFigs.h.

Definition at line 75 of file MuonCalibFigs.h.

IDaqDetailsSvc* MuonCalibFigs::m_daqDetailsSvc [private]

Definition at line 77 of file MuonCalibFigs.h.

Definition at line 79 of file MuonCalibFigs.h.

Definition at line 80 of file MuonCalibFigs.h.

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

Definition at line 81 of file MuonCalibFigs.h.

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

Definition at line 82 of file MuonCalibFigs.h.

Definition at line 85 of file MuonCalibFigs.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:01:29 for MuonBasicFigs by doxygen 1.7.4