DasAcquisition.h

/*-----------------------------------------------------------------------
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"; you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-----------------------------------------------------------------------*/
#pragma once

#include "prodml2_0/AbstractObject.h"
#include "resqml2/AbstractValuesProperty.h"

namespace COMMON_NS {
    class HdfProxy;
}

namespace PRODML2_0_NS
{
    class DLL_IMPORT_OR_EXPORT DasAcquisition : public PRODML2_0_NS::AbstractObject
    {
    private:
        gsoap_eml2_1::prodml2__DasRaw* pushBackRawXmlOnly(const std::string & uuid, const std::string & rawDataUnit, const ULONG64 & startLocusIndex, const ULONG64 & numberOfLoci, const std::string & rawDescription,
            const std::string & startTime, const std::string endTime, const ULONG64 & timeCount,
            gsoap_eml2_1::prodml2__DasDimensions slowestHdfDimension, gsoap_eml2_1::prodml2__DasDimensions fastestHdfDimension,
            bool datatypeIsInteger,
            COMMON_NS::AbstractHdfProxy* proxy);

    public:
        DasAcquisition() {}

        DasAcquisition(class FiberOpticalPath* fiberOpticalPath, class DasInstrumentBox* dasInstrumentBox,
            const std::string & guid, const std::string & title,
            const std::string & jobUuid, const std::string & facilityId, const std::string & vendorName,
            const double & pulseRate, const gsoap_eml2_1::eml21__FrequencyUom & pulseRateUom,
            const double & pulseWidth, const gsoap_eml2_1::eml21__TimeUom & pulseWidthUom,
            const double & gaugeLength, const gsoap_eml2_1::eml21__LengthUom & gaugeLengthUom,
            const double & spatialSamplingInterval, const gsoap_eml2_1::eml21__LengthUom & spatialSamplingIntervalUom,
            const double & minimumFrequency, const gsoap_eml2_1::eml21__FrequencyUom & minimumFrequencyUom,
            const double & maximumFrequency, const gsoap_eml2_1::eml21__FrequencyUom & maximumFrequencyUom,
            const ULONG64 & lociCount, const ULONG64 & startLocusIndex,
            const std::string & measurementStartIsoTime, bool triggeredMeasurement);

        DasAcquisition(class FiberOpticalPath* fiberOpticalPath, class DasInstrumentBox* dasInstrumentBox,
            PRODML2_0_NS::HdfProxy * proxy);

        DasAcquisition(gsoap_eml2_1::_prodml2__DasAcquisition* fromGsoap) : AbstractObject(fromGsoap) {}

        ~DasAcquisition() {}
        
        static const char* XML_TAG;
        virtual std::string getXmlTag() const {return XML_TAG;}

        void setHdfProxy(COMMON_NS::AbstractHdfProxy * proxy);

        gsoap_eml2_1::eml21__DataObjectReference* getFiberOpticalPathDor() const;
        class FiberOpticalPath* getFiberOpticalPath() const;

        void setFiberOpticalPath(class FiberOpticalPath* fiberOpticalPath);

        gsoap_eml2_1::eml21__DataObjectReference* getDasInstrumentBoxDor() const;
        class DasInstrumentBox* getDasInstrumentBox() const;

        void setDasInstrumentBox(class DasInstrumentBox* dasInstrumentBox);

        std::string getJobUuid() const;
        std::string getFacilityUuid() const; // only the first one for now
        std::string getVendorName() const;

        double getPulseRate() const;
        gsoap_eml2_1::eml21__FrequencyUom getPulseRateUom() const;

        double getPulseWidth() const;
        gsoap_eml2_1::eml21__TimeUom getPulseWidthUom() const;

        double getGaugeLength() const;
        gsoap_eml2_1::eml21__LengthUom getGaugeLengthUom() const;

        double getSpatialSamplingInterval() const;
        gsoap_eml2_1::eml21__LengthUom getSpatialSamplingIntervalUom() const;

        double getMinimumFrequency() const;
        gsoap_eml2_1::eml21__FrequencyUom getMinimumFrequencyUom() const;

        double getMaximumFrequency() const;
        gsoap_eml2_1::eml21__FrequencyUom getMaximumFrequencyUom() const;

        ULONG64 getLociCount() const;
        LONG64 getStartLocusIndex() const;

        std::string getMeasurementStartIsoTime() const;

        bool isTriggeredMeasurement() const;

        void pushBackRaw(const std::string & guid, bool datatypeIsInteger, const char & datatypeByteCount, const std::string & rawDataUnit, LONG64* timeArray, const ULONG64 & timeCount, COMMON_NS::AbstractHdfProxy* proxy);

        void writeIntoDataset(float * data,
            unsigned long numSampleForAllLoci,
            unsigned long timeStepIndex);
        void writeIntoDataset(double * data,
            unsigned long numSampleForAllLoci,
            unsigned long timeStepIndex);
        void writeIntoDataset(LONG64 * data,
            unsigned long numSampleForAllLoci,
            unsigned long timeStepIndex);
        void writeIntoDataset(int * data,
            unsigned long numSampleForAllLoci,
            unsigned long timeStepIndex);
        void writeIntoDataset(short * data,
            unsigned long numSampleForAllLoci,
            unsigned long timeStepIndex);
        void writeIntoDataset(char * data,
            unsigned long numSampleForAllLoci,
            unsigned long timeStepIndex);

        unsigned int getRawCount() const;

        gsoap_eml2_1::prodml2__DasDimensions getRawDataSlowestDimension(const unsigned int & rawIndex) const;

        gsoap_eml2_1::prodml2__DasDimensions getRawDataFastestDimension(const unsigned int & rawIndex) const;

        std::string getRawDataUnit(const unsigned int & rawIndex) const;
        LONG64 getStartLocusIndex(const unsigned int & rawIndex) const;
        ULONG64 getNumberOfLoci(const unsigned int & rawIndex) const;
        ULONG64 getRawDataTimeCount(const unsigned int & rawIndex) const;

        RESQML2_NS::AbstractValuesProperty::hdfDatatypeEnum getRawDataHdfDatatype(const unsigned int & rawIndex) const;

        void getRawDataAsDoubleValues(const unsigned int & rawIndex, double * values);

        void getRawDataAsFloatValues(const unsigned int & rawIndex, float * values);

        void getRawDataAsLongValues(const unsigned int & rawIndex, LONG64 * values);

        void getRawDataAsIntValues(const unsigned int & rawIndex, int * values);

        void getRawDataAsShortValues(const unsigned int & rawIndex, short * values);

        void getRawDataAsCharValues(const unsigned int & rawIndex, char * values);

        void getRawDataTime(const unsigned int & rawIndex, LONG64 * values);

        COMMON_NS::AbstractHdfProxy* getHdfProxy() const;

        std::string getHdfProxyUuid() const;

    private:

        void initHdfAttributes();

        std::vector<epc::Relationship> getAllEpcRelationships() const;
        void importRelationshipSetFromEpc(COMMON_NS::EpcDocument* epcDoc) {}
    };
}