/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 Attributes
IBDBoxCutAlg Class Reference

#include <IBDBoxCutAlg.h>

Collaboration diagram for IBDBoxCutAlg:
Collaboration graph
[legend]

List of all members.

Public Member Functions

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

Private Attributes

IStatisticsSvcm_statsSvc
IJobInfoSvcm_jobInfoSvc
int m_execNumber
DayaBay::Detector m_detector
TH1 * m_energyPromptH
TH1 * m_energyDelayedH
TH1 * m_ibdTimeH
TH2 * m_energyPvsDH
TH1 * m_captureDtH
std::vector< TH1 * > m_promptFlashH
std::vector< TH1 * > m_delayedFlashH
std::string m_coincLocation
std::string m_ibdLocation
std::string m_detectorName
double m_minPromptEnergy
double m_maxPromptEnergy
double m_minDelayedEnergy
double m_maxDelayedEnergy
double m_maxCaptureTime
double m_lastMuonVetoTime
double m_nextMuonVetoTime
std::vector< std::string > m_flasherCutVars
std::vector< double > m_flasherCutMins
std::vector< double > m_flasherCutMaxs
bool m_vetoTriplets
bool m_generateHistograms

Detailed Description

Definition at line 24 of file IBDBoxCutAlg.h.


Constructor & Destructor Documentation

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

Definition at line 20 of file IBDBoxCutAlg.cc.

  : GaudiAlgorithm(name,pSvcLocator),
    m_statsSvc(0),
    m_jobInfoSvc(0),
    m_execNumber(0),
    m_detector(),
    m_energyPromptH(0),
    m_energyDelayedH(0),
    m_ibdTimeH(0),
    m_energyPvsDH(0),
    m_captureDtH(0)
{
  declareProperty("CoincLocation", 
                  m_coincLocation="/Event/Data/Physics/CoincidenceLoose",
                  "Apply IBD cuts to this Coincidence TES path");
  declareProperty("IBDLocation", 
                  m_ibdLocation="/Event/Data/Physics/IBDBoxCut/AD1",
                  "Output path for IBD candidates");
  declareProperty("Detector", 
                  m_detectorName="DayaBayAD1",
                  "Name of detector to process");
  declareProperty("MinPromptEnergy",
                  m_minPromptEnergy=-1*MeV,
                  "Lower cut on prompt energy");
  declareProperty("MaxPromptEnergy", 
                  m_maxPromptEnergy=1e9*MeV,
                  "Upper cut on prompt energy");
  declareProperty("MinDelayedEnergy", 
                  m_minDelayedEnergy=-1*MeV,
                  "Lower cut on delayed neutron capture energy");
  declareProperty("MaxDelayedEnergy", 
                  m_maxDelayedEnergy=1e9*MeV,
                  "Upper cut on delayed neutron capture energy");
  declareProperty("MaxCaptureTime",
                  m_maxCaptureTime=1e9*s,
                  "Maximum delayed neutron capture time");
  declareProperty("LastMuonVetoTime",
                  m_lastMuonVetoTime=1e9*s,
                  "Veto time after last muon pool trigger");
  declareProperty("NextMuonVetoTime",
                  m_nextMuonVetoTime=1e9*s,
                  "Veto time before next muon pool trigger");
  declareProperty("FlasherCutVars",
                  m_flasherCutVars,
                  "Variables for flasher cut");
  declareProperty("FlasherCutMins",
                  m_flasherCutMins,
                  "Minimum allowed values for each flasher cut variable");
  declareProperty("FlasherCutMaxs",
                  m_flasherCutMaxs,
                  "Maximum allowed values for each flasher cut variable");
  declareProperty("VetoTriplets",
                  m_vetoTriplets=false,
                  "Veto sets with more than one IBD candidate pair?");
  declareProperty("GenerateHistograms",
                  m_generateHistograms=false,
                  "Generate IBD candidate histograms");
}
IBDBoxCutAlg::~IBDBoxCutAlg ( ) [virtual]

Definition at line 80 of file IBDBoxCutAlg.cc.

{
}

Member Function Documentation

StatusCode IBDBoxCutAlg::initialize ( ) [virtual]

Definition at line 84 of file IBDBoxCutAlg.cc.

{
  // Initialize
  m_detector = DayaBay::Detector(m_detectorName);
  // Initialize the necessary services  
  if(m_generateHistograms){
    StatusCode sc = this->service("StatisticsSvc",m_statsSvc,true);
    if(sc.isFailure()){
      error() << "Failed to get StatisticsSvc" << endreq;
      return sc;
    }
  }
  if(m_ibdLocation.size()>0){
    StatusCode sc = this->service("JobInfoSvc",m_jobInfoSvc,true);
    if(sc.isFailure()){
      error() << "Failed to get JobInfoSvc" << endreq;
      return sc;
    }
  }
  m_execNumber=0;

  // Check flasher cuts
  if(m_flasherCutVars.size()!=m_flasherCutMins.size()
     || m_flasherCutVars.size()!=m_flasherCutMaxs.size()){
    error() << "Invalid description for flasher cuts" << endreq;
    return StatusCode::FAILURE;
  }
  // Zero histogram handles
  for(unsigned int flashCutIdx=0; 
      flashCutIdx<m_flasherCutVars.size(); 
      flashCutIdx++){
    m_promptFlashH.push_back(0);
    m_delayedFlashH.push_back(0);
  }
  return StatusCode::SUCCESS;
}
StatusCode IBDBoxCutAlg::execute ( ) [virtual]

Definition at line 121 of file IBDBoxCutAlg.cc.

{
  // Apply cuts to coincidence data
  m_execNumber++;

  if(!exist<DayaBay::UserDataHeader>(m_coincLocation)){
    // No coincidence data this cycle
    return StatusCode::SUCCESS;
  }

  DayaBay::UserDataHeader* coincHeader = 
    get<DayaBay::UserDataHeader>(m_coincLocation);
  if(!coincHeader){
    error() << "Failed to get Coincidence header" << endreq;
    return StatusCode::FAILURE;
  }

  DayaBay::Detector detector(coincHeader->context().GetSite(),
                             coincHeader->context().GetDetId());
  if(detector != m_detector){
    // Only process the requested detector
    // info() << "Not processing detector " << detector.detName() << endreq;
    return StatusCode::SUCCESS;
  }

  int run = coincHeader->getInt("runNo");
  unsigned int multiplicity 
    = coincHeader->getInt("multiplicity");
  const std::vector<int>& t_s 
    = coincHeader->getIntArray("t_s");
  const std::vector<int>& t_ns 
    = coincHeader->getIntArray("t_ns");
  const std::vector<float>& e 
    = coincHeader->getFloatArray("e");
  const std::vector<int>& energyStatus 
    = coincHeader->getIntArray("energyStatus");
  const std::vector<int>& dt_ns 
    = coincHeader->getIntArray("dt_ns");
  const std::vector<float>& dtLastIWS_ms 
    = coincHeader->getFloatArray("calib_dtLastIWS_ms");
  const std::vector<float>& dtLastOWS_ms 
    = coincHeader->getFloatArray("calib_dtLastOWS_ms");
  const std::vector<float>& dtNextIWS_ms 
    = coincHeader->getFloatArray("calib_dtNextIWS_ms");
  const std::vector<float>& dtNextOWS_ms 
    = coincHeader->getFloatArray("calib_dtNextOWS_ms");
  //std::vector< std::vector<float> const * > flashVars;
  std::vector< std::vector<float> > flashVars;
  for(unsigned int flashCutIdx=0; 
      flashCutIdx<m_flasherCutVars.size(); 
      flashCutIdx++){
    const std::vector<float>& flashVar
      = coincHeader->getFloatArray(m_flasherCutVars[flashCutIdx]);
    flashVars.push_back( flashVar );
  }

  std::vector<int> promptIBD;  // Prompt event indices that pass cuts
  std::vector<int> delayedIBD; // Delayed event indices that pass cuts
  std::vector<int> eHistPIDX;  // Prompt indices for energy histgrm
  std::vector<int> eHistDIDX;  // Delayed indices for energy histgrm
  std::vector<int> dtHistPIDX; // Prompt indices for dt histgrm
  std::vector<int> dtHistDIDX; // Delayed indices for dt histgrm
  std::vector<int> flasherPIDX; // Prompt indices for flashers
  std::vector<int> flasherDIDX; // Delayed indices for flashers
  std::vector<int> failFlashCut; // Delayed indices for flashers
  for(unsigned int promptIdx=0;promptIdx<multiplicity-1;promptIdx++){
    for(unsigned int delayedIdx=promptIdx+1;
        delayedIdx<multiplicity;
        delayedIdx++){

      // Check box cuts for each prompt/delayed pair
      bool promptEOk = false;
      bool delayedEOk = false;
      bool captureDtOk = false;
      bool lastMuonDtOk = false;
      bool nextMuonDtOk = false;
      bool allFlashCutOk = false;
      int flashCutFailCount = 0;
      int flashCutFailIdx = 0;
      bool failFlashPrompt = false;

      // Prompt Energy Cut
      if(energyStatus[promptIdx]==ReconStatus::kGood 
         && e[promptIdx]>=m_minPromptEnergy 
         && e[promptIdx]<=m_maxPromptEnergy)
        promptEOk=true;

      // Delayed Energy Cut
      if(energyStatus[delayedIdx]==ReconStatus::kGood 
         && e[delayedIdx]>=m_minDelayedEnergy 
         && e[delayedIdx]<=m_maxDelayedEnergy)
        delayedEOk=true;

      // Neutron Capture Time Cut
      if( (dt_ns[delayedIdx]-dt_ns[promptIdx])*ns <= m_maxCaptureTime )
        captureDtOk=true;

      // Last Muon Veto
      if( (dtLastIWS_ms[promptIdx]*ms >= m_lastMuonVetoTime
           || dtLastIWS_ms[promptIdx] < 0)
          && (dtLastOWS_ms[promptIdx]*ms >= m_lastMuonVetoTime
              || dtLastOWS_ms[promptIdx] < 0)
          && (dtLastIWS_ms[delayedIdx]*ms >= m_lastMuonVetoTime
              || dtLastIWS_ms[delayedIdx] < 0)
          && (dtLastOWS_ms[delayedIdx]*ms >= m_lastMuonVetoTime
              || dtLastOWS_ms[delayedIdx] < 0) )
        lastMuonDtOk=true;
      
      // Next Muon Veto
      if( (dtNextIWS_ms[delayedIdx]*ms >= m_nextMuonVetoTime 
           || dtNextIWS_ms[delayedIdx]*ms < 0) 
          && (dtNextOWS_ms[delayedIdx]*ms >= m_nextMuonVetoTime 
              || dtNextOWS_ms[delayedIdx]*ms < 0) )
        nextMuonDtOk=true;

      allFlashCutOk=true;
      for(unsigned int flashCutIdx=0;
          flashCutIdx<m_flasherCutVars.size(); 
          flashCutIdx++){
        const std::vector<float>& flasherVar = flashVars[flashCutIdx];
        float promptVal = flasherVar[promptIdx]; 
        float delayedVal = flasherVar[delayedIdx];
        float cutMin = m_flasherCutMins[flashCutIdx];
        float cutMax = m_flasherCutMaxs[flashCutIdx];
        // Check prompt event
        if( promptVal < cutMin || promptVal > cutMax ){
          allFlashCutOk = false;
          failFlashPrompt = true;
          flashCutFailIdx=flashCutIdx;
          flashCutFailCount++;
          if(flashCutFailCount>1) break;
        }
        // Check delayed event
        if( delayedVal < cutMin || delayedVal > cutMax ){
          allFlashCutOk = false;
          flashCutFailIdx=flashCutIdx;
          flashCutFailCount++;
          if(flashCutFailCount>1) break;
        }
      }

      // Check result of all cuts
      if(promptEOk && delayedEOk && captureDtOk 
         && lastMuonDtOk && nextMuonDtOk && allFlashCutOk){
        // Passes all cuts, record
        promptIBD.push_back(promptIdx);
        delayedIBD.push_back(delayedIdx);
      }

      // Catch pairs for figures
      if(m_generateHistograms){
        // Energy Histogram (satisfies all cuts but energy)
        if(captureDtOk && lastMuonDtOk && nextMuonDtOk && allFlashCutOk){
          eHistPIDX.push_back(promptIdx);
          eHistDIDX.push_back(delayedIdx);
        }
        // Delayed capture time histogram (satisfies all cuts but capture time)
        if(promptEOk && delayedEOk && lastMuonDtOk && nextMuonDtOk 
           && allFlashCutOk){
          dtHistPIDX.push_back(promptIdx);
          dtHistDIDX.push_back(delayedIdx);
        }
        // Event indices for flasher cut histograms
        if(promptEOk && delayedEOk && lastMuonDtOk && nextMuonDtOk){ 
          if(flashCutFailCount==1){
            // Only fails one flasher cut, so document
            failFlashCut.push_back(flashCutFailIdx);
            if(failFlashPrompt){
              flasherPIDX.push_back(promptIdx);
              flasherDIDX.push_back(-1);
            }else{
              flasherPIDX.push_back(-1);
              flasherDIDX.push_back(delayedIdx);
            }
          }else if(flashCutFailCount==0){
            // Doesn't fail any flasher cut, so record for all
            failFlashCut.push_back(-1);
            flasherPIDX.push_back(promptIdx);
            flasherDIDX.push_back(delayedIdx);
          }
        }
        // Done with index recording
      }
    }
  }

  if(promptIBD.size()>0 && m_ibdLocation.size()>0){
    // Record result
    DayaBay::UserDataHeader* ibdHeader = new DayaBay::UserDataHeader;

    // Initialize the new header
    ibdHeader->setExecNumber(m_execNumber);    
    ibdHeader->setJobId(m_jobInfoSvc->currentJobInfo()->jobId());    
    ibdHeader->setContext(coincHeader->context());
    ibdHeader->setEarliest(coincHeader->earliest());
    ibdHeader->setLatest(coincHeader->latest());
    ibdHeader->addInputHeader(coincHeader);

    // Set user data
    ibdHeader->set("pairCount",(int)promptIBD.size());
    ibdHeader->set("I",promptIBD);
    ibdHeader->set("J",delayedIBD);

    // Add to event store
    try {
      put(ibdHeader,m_ibdLocation);
    } 
    catch (GaudiException) {
      error() << "Failed to add IBD header to event store" << endreq;
      return StatusCode::FAILURE;
    }
  }


  if(m_generateHistograms){
    // Fill histograms
    if(promptIBD.size()<2 || !m_vetoTriplets){
      for(unsigned int idx=0;idx<promptIBD.size();idx++){
        if(!m_energyPromptH){
          // Initialize histograms
          m_energyPromptH = new TH1F("ibdPromptEnergy","Prompt IBD Energy",
                                     120,0,12);
          m_energyPromptH->GetXaxis()->SetTitle("Energy [MeV]");
          m_energyPromptH->GetYaxis()->SetTitle("Events / 100 keV");
          m_energyDelayedH = new TH1F("ibdDelayedEnergy","Delayed IBD Energy",
                                      70,5,12);
          m_energyDelayedH->GetXaxis()->SetTitle("Energy [MeV]");
          m_energyDelayedH->GetYaxis()->SetTitle("Events / 100 keV");
          int tSec = t_s[promptIBD[idx]];
          int minTime = tSec - (tSec % 60); 
          m_ibdTimeH = new TH1F("ibdCandidateTime","IBD Candidate Time",
                                1,minTime,minTime+60);
          m_ibdTimeH->GetXaxis()->SetTitle("Run Time");
          m_ibdTimeH->GetYaxis()->SetTitle("Events [m^{-1}]");
          m_ibdTimeH->GetXaxis()->SetTimeDisplay(1);
          m_ibdTimeH->GetXaxis()->SetTimeFormat(timeFormat);
          m_ibdTimeH->GetXaxis()->SetTimeOffset(0,"gmt");
          m_ibdTimeH->GetXaxis()->SetNdivisions(505);
          std::stringstream path;
          path << "/file1/diagnostics/run_" 
               << std::setfill('0') << std::setw(7) << run << "/detector_" 
               << m_detectorName << "/";
          m_statsSvc->put((path.str()+m_energyPromptH->GetName()).c_str(),
                          m_energyPromptH);
          m_statsSvc->put((path.str()+m_energyDelayedH->GetName()).c_str(),
                          m_energyDelayedH);
          m_statsSvc->put((path.str()+m_ibdTimeH->GetName()).c_str(),
                          m_ibdTimeH);
        }
        m_energyPromptH->Fill(e[promptIBD[idx]]);
        m_energyDelayedH->Fill(e[delayedIBD[idx]]);
        double ibdTime_s = t_s[promptIBD[idx]]
          + t_ns[promptIBD[idx]]*nanosecond/float(second);
        while(ibdTime_s >= m_ibdTimeH->GetXaxis()->GetXmax()){
          StatusCode sc = HistogramTools::extendRange(msgSvc(), m_ibdTimeH, 1);
          if(!sc.isSuccess()) return sc;
        }
        m_ibdTimeH->Fill(ibdTime_s);
      }
    }
    for(unsigned int idx=0;idx<eHistPIDX.size();idx++){
      if(!m_energyPvsDH){
        m_energyPvsDH = new TH2F("ibdPromptVsDelayedEnergy",
                                 "Prompt vs. Delayed IBD Energy",
                                 120,0,12,
                                 120,0,12);
        m_energyPvsDH->GetXaxis()->SetTitle("Prompt Energy [MeV]");
        m_energyPvsDH->GetYaxis()->SetTitle("Delayed Energy [MeV]");
        std::stringstream path;
        path << "/file1/diagnostics/run_" 
             << std::setfill('0') << std::setw(7) << run << "/detector_" 
             << m_detectorName << "/";
        m_statsSvc->put((path.str()+m_energyPvsDH->GetName()).c_str(),
                        m_energyPvsDH);
      }
      float promptE = e[eHistPIDX[idx]];
      float delayedE = e[eHistDIDX[idx]];
      if(m_energyPvsDH->GetXaxis()->GetXmin()<=promptE
         && m_energyPvsDH->GetXaxis()->GetXmax()>promptE 
         && m_energyPvsDH->GetYaxis()->GetXmin()<=delayedE
         && m_energyPvsDH->GetYaxis()->GetXmax()>delayedE){
        // Only fill inside 2D histogram range
        m_energyPvsDH->Fill(promptE,delayedE);
      }
    }
    for(unsigned int idx=0;idx<dtHistPIDX.size();idx++){
      if(!m_captureDtH){
        m_captureDtH = new TH1F("ibdCaptureTime","IBD Candidate Capture Time",
                                200,0,200);
        m_captureDtH->GetXaxis()->SetTitle("#Deltat [#mus]");
        m_captureDtH->GetYaxis()->SetTitle("Events / #mus");
        std::stringstream path;
        path << "/file1/diagnostics/run_" 
             << std::setfill('0') << std::setw(7) << run << "/detector_" 
             << m_detectorName << "/";
        m_statsSvc->put((path.str()+m_captureDtH->GetName()).c_str(),
                        m_captureDtH);
      }
      m_captureDtH->Fill((dt_ns[dtHistDIDX[idx]] - dt_ns[dtHistPIDX[idx]])
                         *nanosecond/float(microsecond));
    }
    // Fill flasher cut histograms
    for(unsigned int idx=0;idx<flasherPIDX.size();idx++){
      // Loop over each IBD pair
      int promptIdx=flasherPIDX[idx];
      int delayedIdx=flasherDIDX[idx];
      int failCutIdx=failFlashCut[idx];
      int minHist = 0;
      int maxHist = m_flasherCutVars.size();
      if(failCutIdx>=0){
        // Catch events that fail only one cut
        minHist = failCutIdx;
        maxHist = failCutIdx+1;
      }
      for(int flashCutIdx=minHist;
          flashCutIdx<maxHist;
          flashCutIdx++){
        // Fill each histogram
        const std::vector<float>& flasherVar = flashVars[flashCutIdx];
        if(promptIdx>=0){
          TH1* promptFlashH = m_promptFlashH[flashCutIdx];
          if(!promptFlashH){
            float cutMin = m_flasherCutMins[flashCutIdx];
            float cutMax = m_flasherCutMaxs[flashCutIdx];
            float dCut = cutMax-cutMin;
            float histMin = cutMin - 1*dCut;
            float histMax = cutMax + 2*dCut;
            const char* varName = m_flasherCutVars[flashCutIdx].c_str();
            promptFlashH = new TH1F(Form("ibdPromptFlashCut_%s",varName),
                                    Form("IBD Prompt flasher cut: %s",varName),
                                    200,histMin,histMax);
            promptFlashH->GetXaxis()->SetTitle(varName);
            promptFlashH->GetYaxis()->SetTitle("Events / bin");
            std::stringstream path;
            path << "/file1/diagnostics/run_" 
                 << std::setfill('0') << std::setw(7) << run << "/detector_" 
                 << m_detectorName << "/";
            m_statsSvc->put((path.str()+promptFlashH->GetName()).c_str(),
                            promptFlashH);
            m_promptFlashH[flashCutIdx] = promptFlashH;
          }
          debug() << " Filling var "<< promptFlashH->GetName() << " = " 
                  << flasherVar[promptIdx] << endreq;
          promptFlashH->Fill(flasherVar[promptIdx]);
        }
        if(delayedIdx>=0){
          TH1* delayedFlashH = m_delayedFlashH[flashCutIdx];
          if(!delayedFlashH){
            float cutMin = m_flasherCutMins[flashCutIdx];
            float cutMax = m_flasherCutMaxs[flashCutIdx];
            float dCut = cutMax-cutMin;
            float histMin = cutMin - 1*dCut;
            float histMax = cutMax + 2*dCut;
            const char* varName = m_flasherCutVars[flashCutIdx].c_str();
            delayedFlashH = new TH1F(Form("ibdDelayedFlashCut_%s",varName),
                                    Form("IBD Delayed flasher cut: %s",varName),
                                    200,histMin,histMax);
            delayedFlashH->GetXaxis()->SetTitle(varName);
            delayedFlashH->GetYaxis()->SetTitle("Events / bin");
            std::stringstream path;
            path << "/file1/diagnostics/run_" 
                 << std::setfill('0') << std::setw(7) << run << "/detector_" 
                 << m_detectorName << "/";
            m_statsSvc->put((path.str()+delayedFlashH->GetName()).c_str(),
                            delayedFlashH);
            m_delayedFlashH[flashCutIdx] = delayedFlashH;
          }
          debug() << " Filling var "<< delayedFlashH->GetName() << " = " 
                  << flasherVar[delayedIdx] << endreq;
          delayedFlashH->Fill(flasherVar[delayedIdx]);
        }       
      }
    }
    // Done filling histograms

  }

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

Definition at line 501 of file IBDBoxCutAlg.cc.

{
  // Finalize
  if(m_statsSvc) m_statsSvc->release();
  if(m_jobInfoSvc) m_jobInfoSvc->release();
  return StatusCode::SUCCESS;
}

Member Data Documentation

Definition at line 38 of file IBDBoxCutAlg.h.

Definition at line 41 of file IBDBoxCutAlg.h.

Definition at line 44 of file IBDBoxCutAlg.h.

Definition at line 47 of file IBDBoxCutAlg.h.

Definition at line 50 of file IBDBoxCutAlg.h.

Definition at line 51 of file IBDBoxCutAlg.h.

TH1* IBDBoxCutAlg::m_ibdTimeH [private]

Definition at line 52 of file IBDBoxCutAlg.h.

Definition at line 53 of file IBDBoxCutAlg.h.

Definition at line 54 of file IBDBoxCutAlg.h.

std::vector<TH1*> IBDBoxCutAlg::m_promptFlashH [private]

Definition at line 55 of file IBDBoxCutAlg.h.

std::vector<TH1*> IBDBoxCutAlg::m_delayedFlashH [private]

Definition at line 56 of file IBDBoxCutAlg.h.

std::string IBDBoxCutAlg::m_coincLocation [private]

Definition at line 60 of file IBDBoxCutAlg.h.

std::string IBDBoxCutAlg::m_ibdLocation [private]

Definition at line 64 of file IBDBoxCutAlg.h.

std::string IBDBoxCutAlg::m_detectorName [private]

Definition at line 68 of file IBDBoxCutAlg.h.

Definition at line 72 of file IBDBoxCutAlg.h.

Definition at line 76 of file IBDBoxCutAlg.h.

Definition at line 80 of file IBDBoxCutAlg.h.

Definition at line 84 of file IBDBoxCutAlg.h.

Definition at line 88 of file IBDBoxCutAlg.h.

Definition at line 92 of file IBDBoxCutAlg.h.

Definition at line 96 of file IBDBoxCutAlg.h.

std::vector<std::string> IBDBoxCutAlg::m_flasherCutVars [private]

Definition at line 100 of file IBDBoxCutAlg.h.

std::vector<double> IBDBoxCutAlg::m_flasherCutMins [private]

Definition at line 104 of file IBDBoxCutAlg.h.

std::vector<double> IBDBoxCutAlg::m_flasherCutMaxs [private]

Definition at line 108 of file IBDBoxCutAlg.h.

Definition at line 112 of file IBDBoxCutAlg.h.

Definition at line 116 of file IBDBoxCutAlg.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:10:59 for IBDBoxCut by doxygen 1.7.4