DybBaseAlg.h

Go to the documentation of this file.

#ifndef DYBBASEALG
#define DYBBASEALG

#include "Event/HeaderObject.h"
#include "GaudiAlg/GaudiAlgorithm.h"
#include "Event/IHeader.h"

#include <vector>

class IJobInfoSvc;

class DybBaseAlg : public GaudiAlgorithm 
{
public:
    DybBaseAlg(const std::string& name, ISvcLocator* pSvcLocator);
    virtual ~DybBaseAlg();
    
    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;

    template <class TYPE>
    TYPE* getTES(std::string location) const;

    template <class TYPE>
    TYPE* getAES(std::string location, int index) const;

    std::vector<DataObject*> getAEScollection(std::string location) const;

    int getExecNum() { return m_execNum; }

    std::string Location() const { return m_location; }

protected:    
    
    void InitializeHeader(DayaBay::HeaderObject* header);
    
    // wrapper of header object constructor, but intializes the header object.
    // - MakeHeader()
    //       : default initializtion, exec number, job id, E/L time set to BOT
    // - MakeHeader(inputHeaders)
    //       : set the inputHeaders and set E/L time to cover the time range of the inputHeaders
    //       : also set the default context to be the same as the first inputHeader
    // - MakeHeader(referenceHeader)
    //       : set the inputHeaders to be a size 1 vector containing the ref Header
    //       : and set everything to be the same as this single ref Header.
    template <class TYPE>
    TYPE* MakeHeader();
    
    template <class TYPE>
    TYPE* MakeHeader(std::vector<const DayaBay::IHeader*>& inputHeaders);
    
    template <class TYPE>
    TYPE* MakeHeader(const DayaBay::IHeader* referenceHeader);
        
    void AppendInputHeader(const DayaBay::HeaderObject* header) const;
    
    DayaBay::HeaderObject* m_headerObject;

    bool m_pullMode;
    
private:

    int m_execNum;

    int m_saveRandomState;

    mutable std::vector<const DayaBay::HeaderObject*> m_inputHeaders;

    std::vector<unsigned long> m_state;
    IJobInfoSvc* m_jobInfoSvc;

protected:

    std::string m_location;

};

template <class TYPE>
TYPE* DybBaseAlg::getTES(std::string location) const
{
    TYPE* obj = get<TYPE>(location);
    // If object happens to be a HeaderObject, save it in the intputHeaders
    DayaBay::HeaderObject* header = dynamic_cast<DayaBay::HeaderObject*>(obj);
    if (header) {
        if (std::find(m_inputHeaders.begin(),m_inputHeaders.end(),header) == m_inputHeaders.end()) {
            this->AppendInputHeader(header);
            debug() << "Saved " << m_inputHeaders.size() 
                   << " input headers from TES, latest: " 
                   << header->name() 
                   << endreq;
        }
    }
    return obj;
}

template <class TYPE>
TYPE* DybBaseAlg::getAES(std::string location, int index) const
{
    if (index<0) return 0;

    std::vector<DataObject*> vec = this->getAEScollection(location);
    if (!vec.size() || index >= vec.size()) return 0;
    DataObject* dobj = vec[index];
    TYPE* obj = dynamic_cast<TYPE*>(dobj);
    if (!obj) return 0;

    DayaBay::HeaderObject* header = dynamic_cast<DayaBay::HeaderObject*>(obj);
    if (header) {
        if (std::find(m_inputHeaders.begin(),m_inputHeaders.end(),header) == m_inputHeaders.end()) {
            this->AppendInputHeader(header);
            debug() << "Saved " << m_inputHeaders.size() 
                   << " input headers from TES, latest: " 
                   << header->name() 
                   << endreq;
        }
    }

    return obj;
}

template <class TYPE>
TYPE* DybBaseAlg::MakeHeader()
{
    TYPE* obj = new TYPE();
    InitializeHeader(obj);
    return obj;
}

template <class TYPE>
TYPE* DybBaseAlg::MakeHeader(std::vector<const DayaBay::IHeader*>& inputHeaders)
{
    TYPE* obj = MakeHeader<TYPE>();
    obj->setInputHeaders(inputHeaders);
    size_t size = inputHeaders.size();
    if (size == 0) {
        warning() << "input header has zero size" << endreq;
        return obj; 
    }
    const DayaBay::HeaderObject* firstHeader = dynamic_cast<const DayaBay::HeaderObject*>(inputHeaders[0]);
    obj->setContext(firstHeader->context());
    obj->setEarliest(firstHeader->earliest());
    if (size > 1) {
        const DayaBay::HeaderObject* lastHeader = dynamic_cast<const DayaBay::HeaderObject*>(inputHeaders[size-1]);
        obj->setLatest(lastHeader->latest());
    }
    else {
        obj->setLatest(firstHeader->latest());
    }
    
    // make sure the time span covers inputHeaders' range
    for (size_t i=1; i<inputHeaders.size(); i++) {
        const DayaBay::HeaderObject* inputHdr = dynamic_cast<const DayaBay::HeaderObject*>(inputHeaders[i]);
        if (inputHdr->earliest() < obj->earliest()) {
            obj->setEarliest(inputHdr->earliest());
        }
        if (inputHdr->latest() > obj->latest()) {
            obj->setLatest(inputHdr->latest());
        }
    }
    
    return obj;
}

template <class TYPE>
TYPE* DybBaseAlg::MakeHeader(const DayaBay::IHeader* referenceHeader)
{
    std::vector<const DayaBay::IHeader*> inputHeaders = std::vector<const DayaBay::IHeader*>();
    inputHeaders.push_back(referenceHeader);
    TYPE* obj = MakeHeader<TYPE>(inputHeaders);
    return obj;
}
    
    
#endif  // DYBBASEALG