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

#include <SpallData.h>

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

List of all members.

Public Member Functions

 SpallData (const std::string &name, ISvcLocator *pSvcLocator)
virtual ~SpallData ()
virtual StatusCode initialize ()
virtual StatusCode execute ()
virtual StatusCode finalize ()
void recordPreviousMuon (const DayaBay::CalibReadoutHeader *calibReadoutHdr, const TimeStamp &currentTimeStamp)
DayaBay::UserDataHeaderGetCurrentHeaderObject () const
virtual StatusCode sysInitialize ()
virtual StatusCode sysExecute ()
virtual StatusCode preExecute ()
virtual StatusCode postExecute ()
virtual StatusCode sysFinalize ()
IDataProviderSvc * arcSvc () const
void putTES (DataObject *obj, std::string location) const
TYPE * getTES (std::string location) const
TYPE * getAES (std::string location, int index) const
std::vector< DataObject * > getAEScollection (std::string location) const
int getExecNum ()
std::string Location () const

Protected Member Functions

DayaBay::UserDataHeaderMakeHeaderObject ()
void InitializeHeader (DayaBay::HeaderObject *header)
TYPE * MakeHeader ()
TYPE * MakeHeader (std::vector< const DayaBay::IHeader * > &inputHeaders)
TYPE * MakeHeader (const DayaBay::IHeader *referenceHeader)
void AppendInputHeader (const DayaBay::HeaderObject *header) const

Protected Attributes

DayaBay::HeaderObjectm_headerObject
bool m_pullMode
std::string m_location

Private Attributes

IJobInfoSvcm_jobInfoSvc
std::vector< const
DayaBay::IHeader * > 
m_promptMuonHeaders
std::vector< const
DayaBay::IHeader * > 
m_retriggerHeaders
std::vector< const
DayaBay::IHeader * > 
m_spallationHeaders
std::string m_calibHeaderLocation
std::string m_calibStatsLocation
std::string m_muonAnyLocation
std::string m_firstMuonTriggerLocation
std::string m_retriggerLocation
bool m_isSimulation
float m_maxSpallTime
TimeStamp m_lastMuonTimeStamp
TimeStamp m_currentMuonTimeStamp
int m_runNumber

Detailed Description

Definition at line 15 of file SpallData.h.


Constructor & Destructor Documentation

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

Definition at line 16 of file SpallData.cc.

  : DybAlgorithm<DayaBay::UserDataHeader>(name,pSvcLocator) {
  m_location = "/Event/Data/Physics/Spallation";

  declareProperty("CalibHeaderLocation", m_calibHeaderLocation="/Event/CalibReadout/CalibReadoutHeader",
                  "Location of the CalibReadoutHeader");
  declareProperty("CalibStatsLocation", m_calibStatsLocation="/Event/Data/CalibStats",
                  "Location of the CalibStats User data");
  declareProperty("MuonAnyLocation", m_muonAnyLocation="/Event/Tag/Muon/MuonAny",
                  "Location of the MuonAny tag");
  declareProperty("FirstMuonTriggerLocation",m_firstMuonTriggerLocation="/Event/Tag/Muon/FirstMuonTrigger",
                  "Location of FirstMuonTrigger tag");
  declareProperty("RetriggerLocation", m_retriggerLocation="/Event/Tag/Muon/Retrigger",
                  "Location of Retrigger tag");
  declareProperty("IsSimulation", m_isSimulation=false,
                  "Simulation flag");
  declareProperty("MaxSpallTime", m_maxSpallTime = 0.2 * Gaudi::Units::second,
                  "Maximum spallation time window");

  m_promptMuonHeaders.clear();
  m_retriggerHeaders.clear();
  m_spallationHeaders.clear();

  m_lastMuonTimeStamp = TimeStamp(0, 0);
  m_currentMuonTimeStamp = TimeStamp(0, 0);
  m_runNumber = 0;
}
SpallData::~SpallData ( ) [virtual]

Definition at line 44 of file SpallData.cc.

                      {
}

Member Function Documentation

StatusCode SpallData::initialize ( ) [virtual]

Definition at line 47 of file SpallData.cc.

                                 {
  StatusCode sc = this->GaudiAlgorithm::initialize();
  if(sc.isFailure()) return sc;
  
  m_promptMuonHeaders.clear();
  m_retriggerHeaders.clear();
  m_spallationHeaders.clear();

  return StatusCode::SUCCESS;
}
StatusCode SpallData::execute ( ) [virtual]

Definition at line 67 of file SpallData.cc.

                              {
  
  StatusCode sc = StatusCode::SUCCESS;

  const DayaBay::ReadoutHeader *readoutHdr = 0; 
  const DayaBay::CalibReadoutHeader *calibReadoutHdr = 0;  // DayaBay::CLID_CalibReadoutHeader
  DayaBay::UserDataHeader *calibStatsHdr = 0; 

  bool isMuon = false;
  bool isRetrigger = false;
  bool isFirstMuonTrigger = false;

  if ( !exist<DayaBay::CalibReadoutHeader>(evtSvc(), m_calibHeaderLocation) ) {
    warning() << "Cannot find header at " << m_calibHeaderLocation << endreq;
    return StatusCode::FAILURE;
  } else {
    calibReadoutHdr = get<DayaBay::CalibReadoutHeader>(m_calibHeaderLocation);
  } 

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

  isMuon = exist<DayaBay::HeaderObject>(evtSvc(), m_muonAnyLocation);
  isRetrigger = exist<DayaBay::HeaderObject>(evtSvc(), m_retriggerLocation);
  isFirstMuonTrigger = exist<DayaBay::HeaderObject>(evtSvc(), m_firstMuonTriggerLocation);
  
  Site::Site_t siteId = calibReadoutHdr->context().GetSite();
  
  if (siteId == Site::kSAB) {
    return StatusCode::SUCCESS;
  }
  
  if (!exist<DayaBay::ReadoutHeader>(evtSvc(), "/Event/Readout/ReadoutHeader")) {
    warning() << "Failed to get readout, setting run number to 0" << endreq;
    m_runNumber = 0;
  } else {
    readoutHdr = get<DayaBay::ReadoutHeader>("/Event/Readout/ReadoutHeader");
    const DayaBay::DaqCrate* daqCrate = readoutHdr->daqCrate();

    if (!daqCrate) {
      warning() << "Failed to get daq crate, setting run number to 0" << endreq;
      m_runNumber = 0;
    } else {
      m_runNumber = daqCrate->runNumber();
    }
  }
  
  const TimeStamp& currentTimeStamp = calibReadoutHdr->timeStamp();
  DetectorId::DetectorId_t detectorId = calibReadoutHdr->context().GetDetId();

  // check time since current muon
  
  float dtCurrentMuon = -1 * Gaudi::Units::second;
  
  if (!m_currentMuonTimeStamp.IsNull()) {
    TimeStamp dtCurrentMuonTS(currentTimeStamp);
    dtCurrentMuonTS.Subtract(m_currentMuonTimeStamp);
    dtCurrentMuon = dtCurrentMuonTS.GetSeconds() * Gaudi::Units::second;
  }

  if (isFirstMuonTrigger || dtCurrentMuon > m_maxSpallTime) {
    TimeStamp nextMuonTime(0,0);

    if (isFirstMuonTrigger) {
      nextMuonTime = currentTimeStamp;
    }

    this->recordPreviousMuon(calibReadoutHdr, nextMuonTime);

    m_promptMuonHeaders.clear();
    m_retriggerHeaders.clear();
    m_spallationHeaders.clear();
  }

  if (isFirstMuonTrigger) {
    
    if (!m_currentMuonTimeStamp.IsNull()) {
      m_lastMuonTimeStamp = m_currentMuonTimeStamp;
    }

    m_currentMuonTimeStamp = currentTimeStamp;
  }
    
  if (isMuon && !isRetrigger) {

    m_promptMuonHeaders.push_back(calibReadoutHdr);
    m_promptMuonHeaders.push_back(calibStatsHdr);
  } else {
      
    if (isRetrigger) {

      m_retriggerHeaders.push_back(calibReadoutHdr);
      m_retriggerHeaders.push_back(calibStatsHdr);
    }

    if (detectorId==DetectorId::kAD1 || detectorId == DetectorId::kAD2
        || detectorId == DetectorId::kAD3 || detectorId == DetectorId::kAD4) {
      
      if (exist<DayaBay::RecHeader>(evtSvc(), "/Event/Rec/AdSimple")) {
        const DayaBay::RecHeader *recHdr = get<DayaBay::RecHeader>("/Event/Rec/AdSimple");
        m_spallationHeaders.push_back(recHdr);
        m_spallationHeaders.push_back(calibStatsHdr); //for adding flasher variables
      }
    }
  }
  
  return sc;
}
StatusCode SpallData::finalize ( ) [virtual]

Definition at line 58 of file SpallData.cc.

void SpallData::recordPreviousMuon ( const DayaBay::CalibReadoutHeader calibReadoutHdr,
const TimeStamp currentTimeStamp 
)

Definition at line 180 of file SpallData.cc.

                                                                                                                      {

  // record the spallation data from the previous muon
  
  if (m_promptMuonHeaders.size()<1) return;

  DayaBay::UserDataHeader* spallData = MakeHeaderObject();
  
  Context context = calibReadoutHdr->context();
  context.SetDetId(DetectorId::kAll);
  spallData->setContext(context);
  spallData->setEarliest(calibReadoutHdr->earliest());
  spallData->setLatest(calibReadoutHdr->latest());
  
  const DayaBay::CalibReadoutHeader *firstMuonHdrs = dynamic_cast<const DayaBay::CalibReadoutHeader*>(m_promptMuonHeaders[0]);
  TimeStamp muonTimeStamp = firstMuonHdrs->timeStamp();

  // muonset run number
  spallData->set("runNumber",m_runNumber); 

  // muon set time stamp
  spallData->set("tMu_s", static_cast<int>(muonTimeStamp.GetSec()));
  spallData->set("tMu_ns", muonTimeStamp.GetNanoSec());

  // time since last muon
  float dtLastMu_ms = 0.;

  if (!m_lastMuonTimeStamp.IsNull()) {
    TimeStamp dtLastMu(muonTimeStamp);
    dtLastMu.Subtract(m_lastMuonTimeStamp);
    dtLastMu_ms = ( dtLastMu.GetSeconds() * Gaudi::Units::second ) / Gaudi::Units::millisecond;
  }

  spallData->set("dtLastMu_ms", dtLastMu_ms);
  
  // time to next muon

  float dtNextMu_ms = -1 * Gaudi::Units::second;
  
  if (!currentTimeStamp.IsNull()) {
    TimeStamp dtNextMu(currentTimeStamp);
    dtNextMu.Subtract(muonTimeStamp);
    dtNextMu_ms = ( dtNextMu.GetSeconds() * Gaudi::Units::second ) / Gaudi::Units::millisecond;
  }

  spallData->set("dtNextMu_ms", dtNextMu_ms);

  int default_int = -1;
  float default_float = -1.0;
  
  spallData->set("hitAD1", default_int);
  spallData->set("dtAD1_ms", default_float);
  spallData->set("triggerNumber_AD1", default_int);
  spallData->set("triggerType_AD1", default_int);
  spallData->set("calib_nPESum_AD1", default_float);
  spallData->set("calib_nHit_AD1", default_int);

  spallData->set("hitAD2", default_int);
  spallData->set("dtAD2_ms", default_float);
  spallData->set("triggerNumber_AD2", default_int);
  spallData->set("triggerType_AD2", default_int);
  spallData->set("calib_nPESum_AD2", default_float);
  spallData->set("calib_nHit_AD2", default_int);

  spallData->set("hitAD3", default_int);
  spallData->set("dtAD3_ms", default_float);
  spallData->set("triggerNumber_AD3", default_int);
  spallData->set("triggerType_AD3", default_int);
  spallData->set("calib_nPESum_AD3", default_float);
  spallData->set("calib_nHit_AD3", default_int);

  spallData->set("hitAD4", default_int);
  spallData->set("dtAD4_ms", default_float);
  spallData->set("triggerNumber_AD4", default_int);
  spallData->set("triggerType_AD4", default_int);
  spallData->set("calib_nPESum_AD4", default_float);
  spallData->set("calib_nHit_AD4", default_int);

  spallData->set("hitIWS", default_int);
  spallData->set("dtIWS_ms", default_float);
  spallData->set("triggerNumber_IWS", default_int);
  spallData->set("triggerType_IWS", default_int);
  spallData->set("calib_nPESum_IWS", default_float);
  spallData->set("calib_nHit_IWS", default_int);

  spallData->set("hitOWS", default_int);
  spallData->set("dtOWS_ms", default_float);
  spallData->set("triggerNumber_OWS", default_int);
  spallData->set("triggerType_OWS", default_int);
  spallData->set("calib_nPESum_OWS", default_float);
  spallData->set("calib_nHit_OWS", default_int);

  spallData->set("hitRPC", default_int);
  spallData->set("dtRPC_ms", default_float);
  spallData->set("triggerNumber_RPC", default_int);
  spallData->set("triggerType_RPC", default_int);
  spallData->set("calib_nPESum_RPC", default_float);
  spallData->set("calib_nHit_RPC", default_int);

  for (unsigned int ihdr =0; ihdr<m_promptMuonHeaders.size(); ++ihdr) {
    
    const DayaBay::CalibReadoutHeader *muonCalibHdr = dynamic_cast<const DayaBay::CalibReadoutHeader*>(m_promptMuonHeaders[ihdr]);
    DayaBay::UserDataHeader *muonCalibStatsHdr = const_cast<DayaBay::UserDataHeader*>(dynamic_cast<const DayaBay::UserDataHeader*>(m_promptMuonHeaders[++ihdr]));
    
    DetectorId::DetectorId_t detectorId = muonCalibHdr->context().GetDetId();
    
    TimeStamp dtPrompt(muonCalibHdr->timeStamp());
    dtPrompt.Subtract(muonTimeStamp);
    float dtPrompt_ms = (dtPrompt.GetSeconds() * Gaudi::Units::second) / Gaudi::Units::millisecond;
    
    int triggerNumber = 0;
    int triggerType = 0;

    const DayaBay::CalibReadout* calibReadout = muonCalibHdr->calibReadout();
    
    if (calibReadout) {
      triggerNumber = calibReadout->triggerNumber();
      triggerType = calibReadout->triggerType();
    } 

    float nPESumPrompt = muonCalibStatsHdr->getFloat("NominalCharge");
    int nHitPrompt = muonCalibStatsHdr->getInt("nHit");

    if (detectorId == DetectorId::kAD1) {
      spallData->set("hitAD1", 1);
      spallData->set("dtAD1_ms", dtPrompt_ms);
      spallData->set("triggerNumber_AD1", triggerNumber);
      spallData->set("triggerType_AD1", triggerType);
      spallData->set("calib_nPESum_AD1", nPESumPrompt);
      spallData->set("calib_nHit_AD1", nHitPrompt);
    } else if (detectorId == DetectorId::kAD2) {
      spallData->set("hitAD2", 1);
      spallData->set("dtAD2_ms", dtPrompt_ms);
      spallData->set("triggerNumber_AD2", triggerNumber);
      spallData->set("triggerType_AD2", triggerType);
      spallData->set("calib_nPESum_AD2", nPESumPrompt);
      spallData->set("calib_nHit_AD2", nHitPrompt);
    } else if (detectorId == DetectorId::kAD3) {
      spallData->set("hitAD3", 1);
      spallData->set("dtAD3_ms", dtPrompt_ms);
      spallData->set("triggerNumber_AD3", triggerNumber);
      spallData->set("triggerType_AD3", triggerType);
      spallData->set("calib_nPESum_AD3", nPESumPrompt);
      spallData->set("calib_nHit_AD3", nHitPrompt);
    } else if (detectorId == DetectorId::kAD4) {
      spallData->set("hitAD4", 1);
      spallData->set("dtAD4_ms", dtPrompt_ms);
      spallData->set("triggerNumber_AD4", triggerNumber);
      spallData->set("triggerType_AD4", triggerType);
      spallData->set("calib_nPESum_AD4", nPESumPrompt);
      spallData->set("calib_nHit_AD4", nHitPrompt);
    } else if (detectorId == DetectorId::kIWS) {
      spallData->set("hitIWS", 1);
      spallData->set("dtIWS_ms", dtPrompt_ms);
      spallData->set("triggerNumber_IWS", triggerNumber);
      spallData->set("triggerType_IWS", triggerType);
      spallData->set("calib_nPESum_IWS", nPESumPrompt);
      spallData->set("calib_nHit_IWS", nHitPrompt);
    } else if (detectorId == DetectorId::kOWS) {
      spallData->set("hitOWS", 1);
      spallData->set("dtOWS_ms", dtPrompt_ms);
      spallData->set("triggerNumber_OWS", triggerNumber);
      spallData->set("triggerType_OWS", triggerType);
      spallData->set("calib_nPESum_OWS", nPESumPrompt);
      spallData->set("calib_nHit_OWS", nHitPrompt);
    } else if (detectorId == DetectorId::kRPC) {
      spallData->set("hitRPC", 1);
      spallData->set("triggerNumber_RPC", triggerNumber);
      spallData->set("triggerType_RPC", triggerType);
      spallData->set("dtRPC_ms", dtPrompt_ms);
    }
  }
  
  int nRetriggers = m_retriggerHeaders.size()/2;
  spallData->set("nRetriggers", nRetriggers);

  std::vector<float> dtRetrigger_ms;
  std::vector<int> detectorId_rt;
  std::vector<int> triggerNumber_rt;
  std::vector<int> triggerType_rt;
  std::vector<float> calib_nPESum_rt;

  for (unsigned int ihdr =0; ihdr<m_retriggerHeaders.size(); ihdr++) {
    
    const DayaBay::CalibReadoutHeader *retrigCalibHdr = dynamic_cast<const DayaBay::CalibReadoutHeader*>(m_retriggerHeaders[ihdr]);
    DayaBay::UserDataHeader *retrigCalibStatsHdr = const_cast<DayaBay::UserDataHeader*>(dynamic_cast<const DayaBay::UserDataHeader*>(m_retriggerHeaders[++ihdr]));

    DetectorId::DetectorId_t detectorId = retrigCalibHdr->context().GetDetId();
    
    TimeStamp dtRetrigger(retrigCalibHdr->timeStamp());
    dtRetrigger.Subtract(muonTimeStamp);
    dtRetrigger_ms.push_back((dtRetrigger.GetSeconds() * Gaudi::Units::second) / Gaudi::Units::millisecond);
    detectorId_rt.push_back(detectorId);
    
    const DayaBay::CalibReadout* calibReadout = retrigCalibHdr->calibReadout();
    
    if (calibReadout) {
      triggerNumber_rt.push_back(calibReadout->triggerNumber());
      triggerType_rt.push_back(calibReadout->triggerType());
    } else {
      triggerNumber_rt.push_back(0);
      triggerType_rt.push_back(0);
    }

    if (detectorId != DetectorId::kRPC) {
      calib_nPESum_rt.push_back(retrigCalibStatsHdr->getFloat("NominalCharge"));
    } else {
      calib_nPESum_rt.push_back(0);
    }
  }

  spallData->set("dtRetrigger_ms", dtRetrigger_ms);
  spallData->set("detectorId_rt", detectorId_rt);
  spallData->set("triggerNumber_rt", triggerNumber_rt);
  spallData->set("triggerType_rt", triggerType_rt);
  spallData->set("calib_nPESum_rt", calib_nPESum_rt);

  int nSpall = m_spallationHeaders.size()/2;
  spallData->set("nSpall", nSpall);
  
  std::vector<float> dtSpall_ms;
  std::vector<int> detectorId_sp;
  std::vector<int> triggerNumber_sp;
  std::vector<int> triggerType_sp;
  std::vector<int> energyStatus_sp;
  std::vector<float> energy_sp;
  std::vector<int> positionStatus_sp;
  std::vector<float> x_sp;
  std::vector<float> y_sp;
  std::vector<float> z_sp;

  //PMT Flasher discriminators for Spall events
  std::vector<float> middleTimeRMS_sp;
  std::vector<float> maxQ_sp;
  std::vector<float> quadrant_sp;
  std::vector<float> peakRMS_sp;
  std::vector<float> kurtosis_sp;

  std::vector<float> time_PSD_sp;
  std::vector<float> time_PSD1_sp;
  std::vector<float> q1_sp;
  std::vector<float> q2_sp;
  std::vector<float> q3_sp;
  std::vector<float> nPEMax_sp;
  std::vector<float> nPESum_sp;
  std::vector<float> flasher_flag_sp;

  for (unsigned int ihdr =0; ihdr<m_spallationHeaders.size(); ihdr++) {
    
    const DayaBay::RecHeader *spallHdr = dynamic_cast<const DayaBay::RecHeader*>(m_spallationHeaders[ihdr]);
    //Get CalibStatsHeader
    DayaBay::UserDataHeader *spallCalibStatsHdr = const_cast<DayaBay::UserDataHeader*>(dynamic_cast<const DayaBay::UserDataHeader*>(m_spallationHeaders[++ihdr]));
    
    DetectorId::DetectorId_t detectorId = spallHdr->context().GetDetId();
    
    TimeStamp dtSpall(spallHdr->timeStamp());
    dtSpall.Subtract(muonTimeStamp);
    dtSpall_ms.push_back( ( dtSpall.GetSeconds() * Gaudi::Units::second ) / Gaudi::Units::millisecond);
    detectorId_sp.push_back(detectorId);
    
    const DayaBay::RecTrigger& rectrigger = spallHdr->recTrigger();

    triggerNumber_sp.push_back(rectrigger.triggerNumber());
    triggerType_sp.push_back(rectrigger.triggerType());
    energyStatus_sp.push_back(rectrigger.energyStatus());
    energy_sp.push_back(rectrigger.energy()/Gaudi::Units::MeV);
    positionStatus_sp.push_back(rectrigger.positionStatus());
    x_sp.push_back(rectrigger.position().x() / Gaudi::Units::mm);
    y_sp.push_back(rectrigger.position().y() / Gaudi::Units::mm);
    z_sp.push_back(rectrigger.position().z() / Gaudi::Units::mm);

    //Get PMT Flasher discriminators from CalibStatsHeader
    middleTimeRMS_sp.push_back(spallCalibStatsHdr->getFloat("MiddleTimeRMS"));
    maxQ_sp.push_back(spallCalibStatsHdr->getFloat("MaxQ"));
    quadrant_sp.push_back(spallCalibStatsHdr->getFloat("Quadrant"));
    peakRMS_sp.push_back(spallCalibStatsHdr->getFloat("PeakRMS"));
    kurtosis_sp.push_back(spallCalibStatsHdr->getFloat("Kurtosis"));

    time_PSD_sp.push_back(spallCalibStatsHdr->getFloat("time_PSD"));
    time_PSD1_sp.push_back(spallCalibStatsHdr->getFloat("time_PSD1"));
    q1_sp.push_back(spallCalibStatsHdr->getFloat("Q1"));
    q2_sp.push_back(spallCalibStatsHdr->getFloat("Q2"));
    q3_sp.push_back(spallCalibStatsHdr->getFloat("Q3"));
    nPEMax_sp.push_back(spallCalibStatsHdr->getFloat("nPEMax"));
    nPESum_sp.push_back(spallCalibStatsHdr->getFloat("nPESum"));
    flasher_flag_sp.push_back(spallCalibStatsHdr->getFloat("flasher_flag"));
  }

  spallData->set("dtSpall_ms", dtSpall_ms);
  spallData->set("detectorId_sp", detectorId_sp);
  spallData->set("triggerNumber_sp", triggerNumber_sp);
  spallData->set("triggerType_sp", triggerType_sp);
  spallData->set("energyStatus_sp", energyStatus_sp);
  spallData->set("energy_sp", energy_sp);
  spallData->set("positionStatus_sp", positionStatus_sp);
  spallData->set("x_sp", x_sp);
  spallData->set("y_sp", y_sp);
  spallData->set("z_sp", z_sp);

  //Save PMT Flasher discriminators
  spallData->set("middleTimeRMS_sp", middleTimeRMS_sp);
  spallData->set("maxQ_sp", maxQ_sp);
  spallData->set("quadrant_sp", quadrant_sp);
  spallData->set("peakRMS_sp", peakRMS_sp);
  spallData->set("kurtosis_sp", kurtosis_sp);

  spallData->set("time_PSD_sp", time_PSD_sp);
  spallData->set("time_PSD1_sp", time_PSD1_sp);
  spallData->set("q1_sp", q1_sp);
  spallData->set("q2_sp", q2_sp);
  spallData->set("q3_sp", q3_sp);
  spallData->set("nPEMax_sp", nPEMax_sp);
  spallData->set("nPESum_sp", nPESum_sp);
  spallData->set("flasher_flag_sp", flasher_flag_sp);
}
DayaBay::UserDataHeader * DybAlgorithm< DayaBay::UserDataHeader >::GetCurrentHeaderObject ( ) const [inherited]
virtual StatusCode DybAlgorithm< DayaBay::UserDataHeader >::sysInitialize ( ) [virtual, inherited]

Reimplemented from DybBaseAlg.

virtual StatusCode DybAlgorithm< DayaBay::UserDataHeader >::sysExecute ( ) [virtual, inherited]

Reimplemented from DybBaseAlg.

virtual StatusCode DybAlgorithm< DayaBay::UserDataHeader >::preExecute ( ) [virtual, inherited]

Reimplemented from DybBaseAlg.

virtual StatusCode DybAlgorithm< DayaBay::UserDataHeader >::postExecute ( ) [virtual, inherited]

Reimplemented from DybBaseAlg.

virtual StatusCode DybAlgorithm< DayaBay::UserDataHeader >::sysFinalize ( ) [virtual, inherited]

Reimplemented from DybBaseAlg.

IDataProviderSvc * DybAlgorithm< DayaBay::UserDataHeader >::arcSvc ( ) const [inherited]

Reimplemented from DybBaseAlg.

void DybAlgorithm< DayaBay::UserDataHeader >::putTES ( DataObject *  obj,
std::string  location 
) const [inherited]

Reimplemented from DybBaseAlg.

TYPE * DybAlgorithm< DayaBay::UserDataHeader >::getTES ( std::string  location) const [inherited]

Reimplemented from DybBaseAlg.

TYPE * DybAlgorithm< DayaBay::UserDataHeader >::getAES ( std::string  location,
int  index 
) const [inherited]

Reimplemented from DybBaseAlg.

std::vector< DataObject * > DybAlgorithm< DayaBay::UserDataHeader >::getAEScollection ( std::string  location) const [inherited]

Reimplemented from DybBaseAlg.

int DybAlgorithm< DayaBay::UserDataHeader >::getExecNum ( ) [inherited]

Reimplemented from DybBaseAlg.

std::string DybAlgorithm< DayaBay::UserDataHeader >::Location ( ) const [inherited]

Reimplemented from DybBaseAlg.

DayaBay::UserDataHeader * DybAlgorithm< DayaBay::UserDataHeader >::MakeHeaderObject ( ) [protected, inherited]
void DybAlgorithm< DayaBay::UserDataHeader >::InitializeHeader ( DayaBay::HeaderObject header) [protected, inherited]

Reimplemented from DybBaseAlg.

TYPE * DybAlgorithm< DayaBay::UserDataHeader >::MakeHeader ( ) [protected, inherited]

Reimplemented from DybBaseAlg.

TYPE * DybAlgorithm< DayaBay::UserDataHeader >::MakeHeader ( std::vector< const DayaBay::IHeader * > &  inputHeaders) [protected, inherited]

Reimplemented from DybBaseAlg.

TYPE * DybAlgorithm< DayaBay::UserDataHeader >::MakeHeader ( const DayaBay::IHeader referenceHeader) [protected, inherited]

Reimplemented from DybBaseAlg.

void DybAlgorithm< DayaBay::UserDataHeader >::AppendInputHeader ( const DayaBay::HeaderObject header) const [protected, inherited]

Reimplemented from DybBaseAlg.


Member Data Documentation

Reimplemented from DybBaseAlg.

Definition at line 28 of file SpallData.h.

std::vector<const DayaBay::IHeader*> SpallData::m_promptMuonHeaders [private]

Definition at line 30 of file SpallData.h.

std::vector<const DayaBay::IHeader*> SpallData::m_retriggerHeaders [private]

Definition at line 31 of file SpallData.h.

std::vector<const DayaBay::IHeader*> SpallData::m_spallationHeaders [private]

Definition at line 32 of file SpallData.h.

std::string SpallData::m_calibHeaderLocation [private]

Definition at line 34 of file SpallData.h.

std::string SpallData::m_calibStatsLocation [private]

Definition at line 35 of file SpallData.h.

std::string SpallData::m_muonAnyLocation [private]

Definition at line 36 of file SpallData.h.

Definition at line 37 of file SpallData.h.

std::string SpallData::m_retriggerLocation [private]

Definition at line 38 of file SpallData.h.

bool SpallData::m_isSimulation [private]

Definition at line 39 of file SpallData.h.

float SpallData::m_maxSpallTime [private]

Definition at line 40 of file SpallData.h.

Definition at line 42 of file SpallData.h.

Definition at line 43 of file SpallData.h.

int SpallData::m_runNumber [private]

Definition at line 44 of file SpallData.h.

Reimplemented from DybBaseAlg.

bool DybAlgorithm< DayaBay::UserDataHeader >::m_pullMode [protected, inherited]

Reimplemented from DybBaseAlg.

std::string DybAlgorithm< DayaBay::UserDataHeader >::m_location [protected, inherited]

Reimplemented from DybBaseAlg.


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:28 for MuonTagging by doxygen 1.7.4