1195 lines
32 KiB
C++
1195 lines
32 KiB
C++
/*
|
|
** CPQDIF_R_Settings class. Implements a PQDIF record "wrapper" for the
|
|
** settings record. You can cast a standard record object to this class.
|
|
** --------------------------------------------------------------------------
|
|
**
|
|
** File name: $Workfile: rec_settings.cpp $
|
|
** Last modified: $Modtime: 2/22/00 5:28p $
|
|
** Last modified by: $Author: Jack $
|
|
**
|
|
** VCS archive path: $Archive: /PQDIF/PQDcom/PQDcom4/pqdiflib/rec_settings.cpp $
|
|
** VCS revision: $Revision: 15 $
|
|
*/
|
|
#include "PQDIF_classes.h"
|
|
|
|
CPQDIF_R_Settings::~CPQDIF_R_Settings()
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
long CPQDIF_R_Settings::GetCountChannels( void )
|
|
{
|
|
long count = 0;
|
|
CPQDIF_E_Collection * pcolCI;
|
|
|
|
pcolCI = GetChannelSettings();
|
|
if( pcolCI )
|
|
{
|
|
count = pcolCI->GetCount();
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
bool CPQDIF_R_Settings::GetConnectionInfo
|
|
(
|
|
UINT4& connectionType
|
|
)
|
|
{
|
|
bool status = false;
|
|
|
|
CPQDIF_E_Scalar * psc;
|
|
|
|
// Init
|
|
connectionType = 0;
|
|
|
|
psc = FindScalarInCollection( m_pcollMain, tagSettingPhysicalConnection );
|
|
if( psc )
|
|
status = psc->GetValueUINT4( connectionType );
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
bool CPQDIF_R_Settings::GetInfo
|
|
(
|
|
TIMESTAMPPQDIF& timeEffective,
|
|
TIMESTAMPPQDIF& timeInstalled,
|
|
TIMESTAMPPQDIF& timeRemoved,
|
|
bool& useCal,
|
|
bool& useTrans
|
|
)
|
|
{
|
|
bool status = false;
|
|
bool foundItem = false;
|
|
|
|
CPQDIF_E_Scalar * psc;
|
|
|
|
// Init
|
|
memset( &timeEffective, 0, sizeof( timeEffective ) );
|
|
memset( &timeInstalled, 0, sizeof( timeEffective ) );
|
|
memset( &timeRemoved, 0, sizeof( timeEffective ) );
|
|
useCal = false;
|
|
useTrans = false;
|
|
|
|
// Find effective time (required)
|
|
status = true;
|
|
if( status )
|
|
{
|
|
status = false;
|
|
psc = FindScalarInCollection( m_pcollMain, tagEffective );
|
|
if( psc )
|
|
{
|
|
foundItem = psc->GetValueTimeStamp( timeEffective );
|
|
if( foundItem )
|
|
{
|
|
status = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find installed time (optional)
|
|
if( status )
|
|
{
|
|
psc = FindScalarInCollection( m_pcollMain, tagTimeInstalled );
|
|
if( psc )
|
|
{
|
|
foundItem = psc->GetValueTimeStamp( timeInstalled );
|
|
}
|
|
}
|
|
|
|
// Find removed time (optional)
|
|
if( status )
|
|
{
|
|
psc = FindScalarInCollection( m_pcollMain, tagTimeRemoved );
|
|
if( psc )
|
|
{
|
|
foundItem = psc->GetValueTimeStamp( timeRemoved );
|
|
}
|
|
}
|
|
|
|
// Find useCal (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
psc = FindScalarInCollection( m_pcollMain, tagUseCalibration );
|
|
if( psc )
|
|
{
|
|
foundItem = psc->GetValueBOOL4( useCal );
|
|
if( foundItem )
|
|
{
|
|
status = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find useTrans (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
psc = FindScalarInCollection( m_pcollMain, tagUseTransducer );
|
|
if( psc )
|
|
{
|
|
foundItem = psc->GetValueBOOL4( useTrans );
|
|
if( foundItem )
|
|
{
|
|
status = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
bool CPQDIF_R_Settings::GetChannelInfo (long idxChannel, UINT4 & idxChannelDefn)
|
|
{
|
|
//
|
|
//
|
|
// Initialize
|
|
//
|
|
bool foundItem = false;
|
|
|
|
idxChannelDefn = 999999999;
|
|
|
|
// Find the appropriate channel collection
|
|
CPQDIF_E_Collection * pcollMain = GetOneChannelSetting( idxChannel );
|
|
if( pcollMain )
|
|
{
|
|
PQDIFValue value;
|
|
// Find channel defn (required)
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagChannelDefnIdx, ID_PHYS_TYPE_UNS_INTEGER4, value );
|
|
if( foundItem )
|
|
{
|
|
idxChannelDefn = value.uint4;
|
|
}
|
|
}
|
|
|
|
return foundItem;
|
|
}
|
|
|
|
#ifdef zap
|
|
//
|
|
//
|
|
// Most of the returned items are optional. This function
|
|
// returns 0 for those that it can't find. It returns all of
|
|
// the values it can find. It should probably return false
|
|
// if it can't find the channel definition index. I didn't
|
|
// change that for fear of side effects.
|
|
//
|
|
// This function should probably not be used. Instead,
|
|
// individual queries on each element would be more appropriate
|
|
// so that proper action can be taken when one is not available.
|
|
// Using a value of 0 to indicate non-use has many potential
|
|
// problems - EWG.
|
|
//
|
|
bool CPQDIF_R_Settings::GetChannelInfo
|
|
(
|
|
long idxChannel,
|
|
UINT4& idxChannelDefn,
|
|
UINT4& triggerTypeID,
|
|
REAL8& fullScale,
|
|
REAL8& noiseFloor,
|
|
REAL8& triggerLow,
|
|
REAL8& triggerHigh,
|
|
REAL8& triggerRate,
|
|
CPQDIF_E_Vector& triggerShapeParam // Array of [3] ... or NULL
|
|
//REAL8 * triggerShapeParam // Array of [3] ... or NULL
|
|
)
|
|
{
|
|
bool status = false;
|
|
bool foundItem;
|
|
|
|
CPQDIF_E_Collection * pcollMain;
|
|
CPQDIF_E_Collection * pcollChannel = NULL;
|
|
CPQDIF_E_Vector * pvect;
|
|
PQDIFValue value;
|
|
|
|
long count;
|
|
long idx;
|
|
double valueREAL8;
|
|
const long countParams = 3;
|
|
|
|
// Find the appropriate channel collection
|
|
pcollMain = GetOneChannelSetting( idxChannel );
|
|
if( pcollMain )
|
|
{
|
|
status = true;
|
|
}
|
|
|
|
// Find channel defn (required)
|
|
if( status )
|
|
{
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagChannelDefnIdx, ID_PHYS_TYPE_UNS_INTEGER4, value );
|
|
if( foundItem )
|
|
{
|
|
idxChannelDefn = value.uint4;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find trigger type (optional)
|
|
if( status )
|
|
{
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagTriggerTypeID, ID_PHYS_TYPE_UNS_INTEGER4, value );
|
|
if( foundItem )
|
|
{
|
|
triggerTypeID = value.uint4;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find full scale (optional)
|
|
if( status )
|
|
{
|
|
// status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagFullScale, ID_PHYS_TYPE_REAL8, value );
|
|
if( foundItem )
|
|
{
|
|
fullScale = value.real8;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find noise floor (optional)
|
|
if( status )
|
|
{
|
|
// status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagNoiseFloor, ID_PHYS_TYPE_REAL8, value );
|
|
if( foundItem )
|
|
{
|
|
noiseFloor = value.real8;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find trigger low (optional)
|
|
if( status )
|
|
{
|
|
// status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagTriggerLow, ID_PHYS_TYPE_REAL8, value );
|
|
if( foundItem )
|
|
{
|
|
triggerLow = value.real8;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find trigger high (optional)
|
|
if( status )
|
|
{
|
|
// status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagTriggerHigh, ID_PHYS_TYPE_REAL8, value );
|
|
if( foundItem )
|
|
{
|
|
triggerHigh = value.real8;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
|
|
// Find trigger rate (optional)
|
|
if( status )
|
|
{
|
|
// status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagTriggerRate, ID_PHYS_TYPE_REAL8, value );
|
|
if( foundItem )
|
|
{
|
|
triggerRate = value.real8;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find trigger shape (optional)
|
|
if( status )
|
|
{
|
|
//status = false;
|
|
|
|
pvect = FindVectorInCollection( pcollMain, tagTriggerShapeParam );
|
|
if( pvect )
|
|
{
|
|
// Check size of vector
|
|
pvect->GetCount( count );
|
|
if( pvect->GetPhysicalType() == ID_PHYS_TYPE_REAL8
|
|
&& count == countParams )
|
|
{
|
|
// Copy them over (pvect --> triggerShapeParam)
|
|
triggerShapeParam.SetCount( count );
|
|
for( idx = 0; idx < count; idx++ )
|
|
{
|
|
pvect->GetValueREAL8( idx, valueREAL8 );
|
|
triggerShapeParam.SetValueREAL8( idx, valueREAL8 );
|
|
}
|
|
status = true;
|
|
|
|
} // Got the right physical type and array size
|
|
} // Found vector
|
|
}
|
|
|
|
return status;
|
|
}
|
|
#endif
|
|
|
|
|
|
bool CPQDIF_R_Settings::GetChanTrans
|
|
(
|
|
long idxChannel,
|
|
UINT4& xdTransformerTypeID,
|
|
REAL8& xdSystemSideRatio,
|
|
REAL8& xdMonitorSideRatio,
|
|
CPQDIF_E_Vector& xdFrequencyResponse // Array [n]... or NULL
|
|
)
|
|
{
|
|
bool status = false;
|
|
bool foundItem;
|
|
|
|
CPQDIF_E_Collection * pcollMain;
|
|
CPQDIF_E_Collection * pcollChannel = NULL;
|
|
CPQDIF_E_Vector * pvect;
|
|
PQDIFValue value;
|
|
|
|
long count;
|
|
long idx;
|
|
double valueREAL8;
|
|
|
|
// Find the appropriate channel collection
|
|
pcollMain = GetOneChannelSetting( idxChannel );
|
|
if( pcollMain )
|
|
{
|
|
status = true;
|
|
}
|
|
|
|
// Find xdTransformerTypeID (required)
|
|
if( status )
|
|
{
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagXDTransformerTypeID, ID_PHYS_TYPE_UNS_INTEGER4, value );
|
|
if( foundItem )
|
|
{
|
|
xdTransformerTypeID = value.uint4;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find xdSystemSideRatio (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagXDSystemSideRatio, ID_PHYS_TYPE_REAL8, value );
|
|
if( foundItem )
|
|
{
|
|
xdSystemSideRatio = value.real8;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find xdMonitorSideRatio (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagXDMonitorSideRatio, ID_PHYS_TYPE_REAL8, value );
|
|
if( foundItem )
|
|
{
|
|
xdMonitorSideRatio = value.real8;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find xdFrequencyResponse (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
|
|
pvect = FindVectorInCollection( pcollMain, tagXDFrequencyResponse );
|
|
if( pvect )
|
|
{
|
|
// Check size of vector
|
|
pvect->GetCount( count );
|
|
if( pvect->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
|
|
{
|
|
// Copy them over (pvect --> triggerShapeParam)
|
|
xdFrequencyResponse.SetCount( count );
|
|
for( idx = 0; idx < count; idx++ )
|
|
{
|
|
pvect->GetValueREAL8( idx, valueREAL8 );
|
|
xdFrequencyResponse.SetValueREAL8( idx, valueREAL8 );
|
|
}
|
|
status = true;
|
|
|
|
} // Got the right physical type and array size
|
|
} // Found vector
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
bool CPQDIF_R_Settings::GetChanCal
|
|
(
|
|
long idxChannel,
|
|
REAL8& calTimeSkew,
|
|
REAL8& calOffset,
|
|
REAL8& calRatio,
|
|
bool& calMustUseARCal,
|
|
CPQDIF_E_Vector& calApplied, // Array [n]
|
|
CPQDIF_E_Vector& calRecorded // Array [n]
|
|
)
|
|
{
|
|
bool status = false;
|
|
bool foundItem;
|
|
|
|
CPQDIF_E_Collection * pcollMain;
|
|
CPQDIF_E_Collection * pcollChannel = NULL;
|
|
CPQDIF_E_Vector * pvect;
|
|
PQDIFValue value;
|
|
|
|
long count;
|
|
long idx;
|
|
double valueREAL8;
|
|
|
|
// Find the appropriate channel collection
|
|
pcollMain = GetOneChannelSetting( idxChannel );
|
|
if( pcollMain )
|
|
{
|
|
status = true;
|
|
}
|
|
|
|
// Find calTimeSkew (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagCalTimeSkew, ID_PHYS_TYPE_REAL8, value );
|
|
if( foundItem )
|
|
{
|
|
calTimeSkew = value.real8;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find calOffset (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagCalOffset, ID_PHYS_TYPE_REAL8, value );
|
|
if( foundItem )
|
|
{
|
|
calOffset = value.real8;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find calRatio (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagCalRatio, ID_PHYS_TYPE_REAL8, value );
|
|
if( foundItem )
|
|
{
|
|
calRatio = value.real8;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find calMustUseARCal (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
foundItem = GetScalarValueInCollection( pcollMain, tagCalMustUseARCal, ID_PHYS_TYPE_BOOLEAN4, value );
|
|
if( foundItem )
|
|
{
|
|
calMustUseARCal = value.bool4 ? true : false;
|
|
status = true;
|
|
}
|
|
}
|
|
|
|
// Find calApplied (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
|
|
pvect = FindVectorInCollection( pcollMain, tagCalApplied );
|
|
if( pvect )
|
|
{
|
|
// Check size of vector
|
|
pvect->GetCount( count );
|
|
if( pvect->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
|
|
{
|
|
// Copy them over (pvect --> triggerShapeParam)
|
|
calApplied.SetCount( count );
|
|
for( idx = 0; idx < count; idx++ )
|
|
{
|
|
pvect->GetValueREAL8( idx, valueREAL8 );
|
|
calApplied.SetValueREAL8( idx, valueREAL8 );
|
|
}
|
|
status = true;
|
|
|
|
} // Got the right physical type and array size
|
|
} // Found vector
|
|
}
|
|
|
|
// Find calRecorded (required)
|
|
if( status )
|
|
{
|
|
status = false;
|
|
|
|
pvect = FindVectorInCollection( pcollMain, tagCalRecorded );
|
|
if( pvect )
|
|
{
|
|
// Check size of vector
|
|
pvect->GetCount( count );
|
|
if( pvect->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
|
|
{
|
|
// Copy them over (pvect --> triggerShapeParam)
|
|
calRecorded.SetCount( count );
|
|
for( idx = 0; idx < count; idx++ )
|
|
{
|
|
pvect->GetValueREAL8( idx, valueREAL8 );
|
|
calRecorded.SetValueREAL8( idx, valueREAL8 );
|
|
}
|
|
status = true;
|
|
|
|
} // Got the right physical type and array size
|
|
} // Found vector
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
// Set functions
|
|
// -------------
|
|
bool CPQDIF_R_Settings::SetConnectionInfo
|
|
(
|
|
const UINT4 connectionType
|
|
)
|
|
{
|
|
bool status = true;
|
|
|
|
CPQDIF_E_Scalar * psc;
|
|
PQDIFValue value;
|
|
|
|
// Set the connection type
|
|
if( status )
|
|
{
|
|
status = false;
|
|
psc = FindOrCreateScalarInCollection( m_pcollMain,
|
|
tagSettingPhysicalConnection, ID_PHYS_TYPE_UNS_INTEGER4 );
|
|
// Set value
|
|
if( psc )
|
|
{
|
|
value.uint4 = connectionType;
|
|
status = psc->SetValue( ID_PHYS_TYPE_UNS_INTEGER4, value );
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
|
|
bool CPQDIF_R_Settings::SetInfo
|
|
(
|
|
const TIMESTAMPPQDIF& timeEffective,
|
|
const TIMESTAMPPQDIF& timeInstalled,
|
|
const TIMESTAMPPQDIF& timeRemoved,
|
|
bool useCal,
|
|
bool useTrans
|
|
)
|
|
{
|
|
bool status = true;
|
|
|
|
CPQDIF_E_Scalar * psc;
|
|
PQDIFValue value;
|
|
CPQDIF_E_Collection * pcolInstances;
|
|
|
|
// Set times ... effective
|
|
if( status )
|
|
{
|
|
status = false;
|
|
psc = FindOrCreateScalarInCollection( m_pcollMain,
|
|
tagEffective, ID_PHYS_TYPE_TIMESTAMPPQDIF );
|
|
// Set value
|
|
if( psc )
|
|
{
|
|
value.ts = timeEffective;
|
|
status = psc->SetValue( ID_PHYS_TYPE_TIMESTAMPPQDIF, value );
|
|
}
|
|
}
|
|
// ... installed
|
|
if( status )
|
|
{
|
|
status = false;
|
|
psc = FindOrCreateScalarInCollection( m_pcollMain,
|
|
tagTimeInstalled, ID_PHYS_TYPE_TIMESTAMPPQDIF );
|
|
// Set value
|
|
if( psc )
|
|
{
|
|
value.ts = timeInstalled;
|
|
status = psc->SetValue( ID_PHYS_TYPE_TIMESTAMPPQDIF, value );
|
|
}
|
|
}
|
|
// ... removed
|
|
if( status )
|
|
{
|
|
status = false;
|
|
psc = FindOrCreateScalarInCollection( m_pcollMain,
|
|
tagTimeRemoved, ID_PHYS_TYPE_TIMESTAMPPQDIF );
|
|
// Set value
|
|
if( psc )
|
|
{
|
|
value.ts = timeRemoved;
|
|
status = psc->SetValue( ID_PHYS_TYPE_TIMESTAMPPQDIF, value );
|
|
}
|
|
}
|
|
|
|
// Flags ... useCal
|
|
if( status )
|
|
{
|
|
status = false;
|
|
psc = FindOrCreateScalarInCollection( m_pcollMain,
|
|
tagUseCalibration, ID_PHYS_TYPE_BOOLEAN4 );
|
|
// Set value
|
|
if( psc )
|
|
{
|
|
value.bool4 = useCal;
|
|
status = psc->SetValue( ID_PHYS_TYPE_BOOLEAN4, value );
|
|
}
|
|
}
|
|
// ... useTrans
|
|
if( status )
|
|
{
|
|
status = false;
|
|
psc = FindOrCreateScalarInCollection( m_pcollMain,
|
|
tagUseTransducer, ID_PHYS_TYPE_BOOLEAN4 );
|
|
// Set value
|
|
if( psc )
|
|
{
|
|
value.bool4 = useTrans;
|
|
status = psc->SetValue( ID_PHYS_TYPE_BOOLEAN4, value );
|
|
}
|
|
}
|
|
|
|
// Is there a 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 );
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
long CPQDIF_R_Settings::AddChannel
|
|
(
|
|
UINT4 idxChannelDefn
|
|
)
|
|
{
|
|
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 );
|
|
}
|
|
|
|
|
|
if( pcolInstances )
|
|
{
|
|
// Get the new index
|
|
idxNew = GetCountChannels();
|
|
|
|
// Create the new channel instance
|
|
CPQDIF_E_Collection * pcollOne = (CPQDIF_E_Collection *) theFactory.NewElement( ID_ELEMENT_TYPE_COLLECTION );
|
|
pcollOne->SetTag( tagOneChannelSetting );
|
|
|
|
// Stuff in the information...
|
|
pcollOne->SetScalarUINT4( tagChannelDefnIdx, idxChannelDefn );
|
|
|
|
// We're done filling the collection ... add it!
|
|
pcolInstances->Add( pcollOne );
|
|
}
|
|
|
|
return idxNew;
|
|
}
|
|
|
|
long CPQDIF_R_Settings::AddChannel
|
|
(
|
|
UINT4 idxChannelDefn,
|
|
UINT4 idTriggerType
|
|
)
|
|
{
|
|
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 );
|
|
}
|
|
|
|
|
|
if( pcolInstances )
|
|
{
|
|
// Get the new index
|
|
idxNew = GetCountChannels();
|
|
|
|
// Create the new channel instance
|
|
CPQDIF_E_Collection * pcollOne = (CPQDIF_E_Collection *) theFactory.NewElement( ID_ELEMENT_TYPE_COLLECTION );
|
|
pcollOne->SetTag( tagOneChannelSetting );
|
|
|
|
// Stuff in the information...
|
|
pcollOne->SetScalarUINT4( tagChannelDefnIdx, idxChannelDefn );
|
|
pcollOne->SetScalarUINT4( tagTriggerTypeID, idTriggerType );
|
|
|
|
// We're done filling the collection ... add it!
|
|
pcolInstances->Add( pcollOne );
|
|
}
|
|
|
|
return idxNew;
|
|
}
|
|
|
|
|
|
|
|
#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;
|
|
}
|
|
|
|
bool CPQDIF_R_Settings::SettagEffectiveAndtagTimeInstalledAndtagTimeRemoved
|
|
(
|
|
const TIMESTAMPPQDIF& timeEffective,
|
|
const TIMESTAMPPQDIF& TimeInstalled,
|
|
const TIMESTAMPPQDIF& TimeRemoved
|
|
)
|
|
{
|
|
bool status = false;
|
|
|
|
CPQDIF_E_Scalar * psc;
|
|
CPQDIF_E_Vector * pvect;
|
|
|
|
if (m_pcollMain == NULL)
|
|
return false;
|
|
// First, find (or create) the trigger method
|
|
psc = FindOrCreateScalarInCollection(m_pcollMain,
|
|
tagEffective, ID_PHYS_TYPE_TIMESTAMPPQDIF);
|
|
// Set its value
|
|
if (psc)
|
|
{
|
|
status = psc->SetValueTimeStamp(timeEffective);
|
|
}
|
|
|
|
// Set the time it was triggered
|
|
if (status)
|
|
{
|
|
status = false;
|
|
psc = FindOrCreateScalarInCollection(m_pcollMain,
|
|
tagTimeInstalled, ID_PHYS_TYPE_TIMESTAMPPQDIF);
|
|
// Set value
|
|
if (psc)
|
|
{
|
|
status = psc->SetValueTimeStamp(TimeInstalled);
|
|
}
|
|
}
|
|
|
|
// Set the time it was triggered
|
|
if (status)
|
|
{
|
|
status = false;
|
|
psc = FindOrCreateScalarInCollection(m_pcollMain,
|
|
tagTimeRemoved, ID_PHYS_TYPE_TIMESTAMPPQDIF);
|
|
// Set value
|
|
if (psc)
|
|
{
|
|
status = psc->SetValueTimeStamp(TimeRemoved);
|
|
}
|
|
}
|
|
return status;
|
|
|
|
} |