rec_settings.cpp

电能质量交换格式转换库

#ifdef zap
//
//
//  This should only be used if all passed in parameters are used
//
long CPQDIF_R_Settings::AddChannel
        (
                UINT4               idxChannelDefn,
                UINT4               triggerTypeID,
                REAL8               fullScale,  
                REAL8               noiseFloor, 
                REAL8               triggerLow, 
                REAL8               triggerHigh,
                REAL8               triggerRate,
                //REAL8 *         triggerShapeParam   //  Array of [3] ... or NULL
        const   CPQDIF_E_Vector *   triggerShapeParam   //  Array of [3] ... or NULL
        ) 
    {
    long        idxNew = -1;
    //
    //
    //  Is there a collection?
    //
    CPQDIF_E_Collection *   pcolInstances = GetChannelSettings(); 
    if( !pcolInstances )
        {
        //  Nope, insert an empty collection ...
        pcolInstances = (CPQDIF_E_Collection *) theFactory.NewElement( ID_ELEMENT_TYPE_COLLECTION );
        pcolInstances->SetTag( tagChannelSettingsArray );
        m_pcollMain->Add( pcolInstances );
        }

    CPQDIF_E_Collection *   pcollOne;

    CPQDIF_E_Vector *       pvect;

    long                    idx;
    long                    count;
    double                  valueParam;
    const long              countParams = 3;

    if( pcolInstances )
        {
        //  Get the new index
        idxNew = GetCountChannels();

        //  Create the new channel instance
        pcollOne = (CPQDIF_E_Collection *) theFactory.NewElement( ID_ELEMENT_TYPE_COLLECTION );
        pcollOne->SetTag( tagOneChannelSetting );

        //  Stuff in the information...
        pcollOne->SetScalarUINT4( tagChannelDefnIdx, idxChannelDefn );
        pcollOne->SetScalarUINT4( tagTriggerTypeID, triggerTypeID );

        //  Thresholds
        pcollOne->SetScalarREAL8( tagFullScale, fullScale );
        pcollOne->SetScalarREAL8( tagNoiseFloor, noiseFloor );
        pcollOne->SetScalarREAL8( tagTriggerLow, triggerLow );
        pcollOne->SetScalarREAL8( tagTriggerHigh, triggerHigh );
        pcollOne->SetScalarREAL8( tagTriggerRate, triggerRate );

        //  Shape param
        pvect = FindOrCreateVectorInCollection( pcollOne, 
                    tagTriggerShapeParam, ID_PHYS_TYPE_REAL8 );
        //  Set its value(s)
        if( pvect && triggerShapeParam )
            {
            //  Validate physical type & size
            pvect->GetCount( count );
            if( pvect->GetPhysicalType() == ID_PHYS_TYPE_REAL8 
                && count == countParams )
                {
                pvect->SetCount( countParams );
                for( idx = 0; idx < countParams; idx++ )
                    {
                    triggerShapeParam->GetValueREAL8( idx, valueParam );
                    pvect->SetValueREAL8( idx, valueParam );
                    }
                }
            }

        //  We're done filling the collection ... add it!
        pcolInstances->Add( pcollOne );
        }

    return idxNew;
    }
#endif

bool CPQDIF_R_Settings::SetTriggerShapeParam
        (
        UINT4                     idxChannel,
        const CPQDIF_E_Vector *   triggerShapeParam   //  Array of [3] ... or NULL
        ) 
    {
    bool    status = false;

    CPQDIF_E_Collection *   pcollOne = GetOneChannelSetting( idxChannel );

    if( pcollOne )
        {
        CPQDIF_E_Vector *  pvect = FindOrCreateVectorInCollection( pcollOne, 
                    tagTriggerShapeParam, ID_PHYS_TYPE_REAL8 );
        //
        //  Set its value(s)
        //
        if( pvect && triggerShapeParam )
            {
            const long              countParams = 3;
            long                    count;
            //
            //
            //  Validate physical type & size
            //
            pvect->GetCount( count );
            if( pvect->GetPhysicalType() == ID_PHYS_TYPE_REAL8 
                && count == countParams )
                {
                double              valueParam;

                pvect->SetCount( countParams );

                for(long idx = 0; idx < countParams; idx++ )
                    {
                    triggerShapeParam->GetValueREAL8( idx, valueParam );
                    pvect->SetValueREAL8( idx, valueParam );
                    }
                status = true;
                }
            }
        }
    return status;
    }


bool CPQDIF_R_Settings::GetChannelReal8(UINT4 idxChannel, GUID tag, REAL8 &dVal)
    {
    bool foundItem = false;

    CPQDIF_E_Collection *   pcollOne = GetOneChannelSetting( idxChannel );

    if( pcollOne )
        {
        PQDIFValue  value;

        foundItem = GetScalarValueInCollection( pcollOne, tag, ID_PHYS_TYPE_REAL8, value );
        if( foundItem )
            {
            dVal = value.real8;
            }
        }
    return foundItem;
    }

bool CPQDIF_R_Settings::SetChannelReal8(UINT4 idxChannel, GUID tag, REAL8 dVal)
    {
    bool    status = false;

    CPQDIF_E_Collection *   pcollOne = GetOneChannelSetting( idxChannel );

    if( pcollOne )
        {
        CPQDIF_E_Scalar * psc = FindOrCreateScalarInCollection( pcollOne,
            tag, ID_PHYS_TYPE_REAL8 );

        if( psc )
            {
            psc->SetValueREAL8(dVal);

            status = true;
            }
        }
    return status;
    }


bool CPQDIF_R_Settings::SetChanTrans
        (
                UINT4               idxChannel,
                UINT4               xdTransformerTypeID,
                REAL8               xdSystemSideRatio,  
                REAL8               xdMonitorSideRatio,
        const   CPQDIF_E_Vector *   xdFrequencyResponse   //  Array [n]... or NULL
        )
{
    bool    status = false;

    CPQDIF_E_Collection *   pcollOne = GetOneChannelSetting( idxChannel );
    CPQDIF_E_Scalar *       psc;
    CPQDIF_E_Vector *       pvect;

    long        idx;
    long        count;
    double      value;

    if( pcollOne )
    {
        //  Scalars
        psc = FindOrCreateScalarInCollection( pcollOne,
            tagXDTransformerTypeID, ID_PHYS_TYPE_UNS_INTEGER4 );
        if( psc )
        {
            psc->SetValueUINT4( xdTransformerTypeID );
        }
        psc = FindOrCreateScalarInCollection( pcollOne,
            tagXDSystemSideRatio, ID_PHYS_TYPE_REAL8 );
        if( psc )
        {
            psc->SetValueREAL8( xdSystemSideRatio );
        }
        psc = FindOrCreateScalarInCollection( pcollOne,
            tagXDMonitorSideRatio, ID_PHYS_TYPE_REAL8 );
        if( psc )
        {
            psc->SetValueREAL8( xdMonitorSideRatio );
        }

        //  Vector
        if( xdFrequencyResponse )
        {
            pvect = FindOrCreateVectorInCollection( pcollOne, 
                    tagXDFrequencyResponse, ID_PHYS_TYPE_REAL8 );
            if( pvect && xdFrequencyResponse->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
            {
                //  Transfer the data over
                xdFrequencyResponse->GetCount( count );
                pvect->SetCount( count );
                for( idx = 0; idx < count; idx++)
                {
                    xdFrequencyResponse->GetValueREAL8( idx, value );
                    pvect->SetValueREAL8( idx, value );
                }
            }
        }

        status = true;
    }

    return status;
}


bool CPQDIF_R_Settings::SetChanCal
        (
                UINT4               idxChannel,
                REAL8               calTimeSkew,  
                REAL8               calOffset,  
                REAL8               calRatio,  
                bool                calMustUseARCal,
        const   CPQDIF_E_Vector *   calApplied,     //  Array [n]... or NULL
        const   CPQDIF_E_Vector *   calRecorded     //  Array [n]... or NULL
        )
{
    bool    status = false;

    CPQDIF_E_Collection *   pcollOne = GetOneChannelSetting( idxChannel );
    CPQDIF_E_Scalar *       psc;
    CPQDIF_E_Vector *       pvect;

    long        idx;
    long        count;
    double      value;

    if( pcollOne )
    {
        //  Scalars
        psc = FindOrCreateScalarInCollection( pcollOne,
                tagCalTimeSkew, ID_PHYS_TYPE_REAL8 );
        if( psc )
        {
            psc->SetValueREAL8( calTimeSkew );
        }
        psc = FindOrCreateScalarInCollection( pcollOne,
                tagCalOffset, ID_PHYS_TYPE_REAL8 );
        if( psc )
        {
            psc->SetValueREAL8( calOffset );
        }
        psc = FindOrCreateScalarInCollection( pcollOne,
                tagCalRatio, ID_PHYS_TYPE_REAL8 );
        if( psc )
        {
            psc->SetValueREAL8( calRatio );
        }
        psc = FindOrCreateScalarInCollection( pcollOne,
                tagCalMustUseARCal, ID_PHYS_TYPE_BOOLEAN4 );
        if( psc )
        {
            psc->SetValueBOOL4( (BOOL4) calMustUseARCal );
        }

        //  Vectors
        if( calApplied && calRecorded )
        {
            //  Applied
            pvect = FindOrCreateVectorInCollection( pcollOne, 
                        tagCalApplied, ID_PHYS_TYPE_REAL8 );
            if( pvect && calApplied->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
            {
                //  Transfer the data over
                calApplied->GetCount( count );
                pvect->SetCount( count );
                for( idx = 0; idx < count; idx++)
                {
                    calApplied->GetValueREAL8( idx, value );
                    pvect->SetValueREAL8( idx, value );
                }
            }

            //  Recorded
            pvect = FindOrCreateVectorInCollection( pcollOne, 
                        tagCalRecorded, ID_PHYS_TYPE_REAL8 );
            if( pvect && calRecorded->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
            {
                //  Transfer the data over
                calRecorded->GetCount( count );
                pvect->SetCount( count );
                for( idx = 0; idx < count; idx++)
                {
                    calRecorded->GetValueREAL8( idx, value );
                    pvect->SetValueREAL8( idx, value );
                }
            }
        }

        status = true;
    }

    return status;
}

    
//  Protected stuff

CPQDIF_E_Collection * CPQDIF_R_Settings::GetChannelSettings( void )
{
    CPQDIF_E_Collection *   pcollSettings;

    //  Create the collection if it does not yet exist.
    pcollSettings = FindCollectionInCollection( m_pcollMain, tagChannelSettingsArray );
    if( !pcollSettings )
    {
        pcollSettings = (CPQDIF_E_Collection *) theFactory.NewElement( ID_ELEMENT_TYPE_COLLECTION );
        if( pcollSettings )
        {
            pcollSettings->SetTag( tagChannelSettingsArray );
            m_pcollMain->Add( pcollSettings );
        }
    }

    return pcollSettings;
}


CPQDIF_E_Collection * CPQDIF_R_Settings::GetOneChannelSetting
        ( 
        long idxChannel
        )
{
    CPQDIF_E_Collection *   pcolReturn = NULL;
    CPQDIF_E_Collection *   pcolInstances = GetChannelSettings();
    CPQDIF_Element *        pel;

    if( pcolInstances )
    {
        pel = pcolInstances->GetElement( idxChannel );
        if( pel )
        {
            if( pel->GetElementType() == ID_ELEMENT_TYPE_COLLECTION
                && PQDIF_IsEqualGUID( pel->GetTag(), tagOneChannelSetting ) )
            {
                pcolReturn = (CPQDIF_E_Collection *) pel;
            }
        }
    }

    return pcolReturn;
}