void
LOCA::Pitchfork::MooreSpence::ExtendedVector::setVec(
const NOX::Abstract::Vector& xVec,
const NOX::Abstract::Vector& nullVec,
double slack,
double bifPar)
{
setVector(0, xVec);
setVector(1, nullVec);
setScalar(0, slack);
setScalar(1, bifPar);
}
LOCA::Pitchfork::MooreSpence::ExtendedVector::ExtendedVector(
const Teuchos::RCP<LOCA::GlobalData>& global_data,
const NOX::Abstract::Vector& xVec,
const NOX::Abstract::Vector& nullVec,
double slack,
double bifParam) :
LOCA::Extended::Vector(global_data,2,2)
{
setVector(0, xVec);
setVector(1, nullVec);
setScalar(0, slack);
setScalar(1, bifParam);
}
void
LOCA::Hopf::MooreSpence::ExtendedVector::setVec(
const NOX::Abstract::Vector& xVec,
const NOX::Abstract::Vector& realEigenVec,
const NOX::Abstract::Vector& imagEigenVec,
double frequency,
double bifPar)
{
setVector(0, xVec);
setVector(1, realEigenVec);
setVector(2, imagEigenVec);
setScalar(0, frequency);
setScalar(1, bifPar);
}
LOCA::Hopf::MooreSpence::ExtendedVector::ExtendedVector(
const Teuchos::RCP<LOCA::GlobalData>& global_data,
const NOX::Abstract::Vector& xVec,
const NOX::Abstract::Vector& realEigenVec,
const NOX::Abstract::Vector& imagEigenVec,
double frequency,
double bifParam) :
LOCA::Extended::Vector(global_data,3,2)
{
setVector(0, xVec);
setVector(1, realEigenVec);
setVector(2, imagEigenVec);
setScalar(0, frequency);
setScalar(1, bifParam);
}
bool SkAnimator::setScalar(const char* id, const char* fieldID, SkScalar scalar) {
SkDisplayable* element = (SkDisplayable*) getElement(id);
if (element == NULL)
return false;
const SkMemberInfo* field = getField(element, fieldID);
if (field == NULL)
return false;
return setScalar(element, field, scalar);
}
void
LOCA::TurningPoint::MooreSpence::ExtendedVector::setVec(
const NOX::Abstract::Vector& xVec,
const NOX::Abstract::Vector& nullVec,
double bifPar)
{
setVector(0, xVec);
setVector(1, nullVec);
setScalar(0, bifPar);
}
void
LOCA::PhaseTransition::ExtendedVector::setVec(
const NOX::Abstract::Vector& x1Vec,
const NOX::Abstract::Vector& x2vec,
double ptp)
{
setVector(0, x1Vec);
setVector(1, x2vec);
setScalar(0, ptp);
}
/*
* This function checks if the given field is a scalar. If the field dosn't
* exist it will set the default value.
*/
static int checkScalar(mxArray *pStruct, const char *fieldname, double defaultValue) {
mxArray *pField;
pField = mxGetField(pStruct, 0,fieldname);
if(NULL == pField) {
setScalar(pStruct,fieldname, defaultValue);
return 1;
} else {
return 1 == mxIsDouble(pField)&& 1 == mxGetM(pField) && 1 == mxGetN(pField);
}
}
LOCA::PhaseTransition::ExtendedVector::ExtendedVector(
const Teuchos::RCP<LOCA::GlobalData>& global_data,
const NOX::Abstract::Vector& x1Vec,
const NOX::Abstract::Vector& x2vec,
double ptp) :
LOCA::Extended::Vector(global_data,2,1)
{
setVector(0, x1Vec);
setVector(1, x2vec);
setScalar(0, ptp);
}
LOCA::TurningPoint::MooreSpence::ExtendedVector::ExtendedVector(
const Teuchos::RCP<LOCA::GlobalData>& global_data,
const NOX::Abstract::Vector& xVec,
const NOX::Abstract::Vector& nullVec,
double bifParam) :
LOCA::Extended::Vector(global_data,2,1)
{
setVector(0, xVec);
setVector(1, nullVec);
setScalar(0, bifParam);
}
void VMMemory::setArrayElement(unsigned dstocEntry, unsigned arrayIndex, int32_t newValue)
{
if (dstocEntry >= programData->getDSTOCCount()) throw std::range_error("Not a DSTOC entry");
// Get element type (which is the DSTOC field right after the one for the
// array)
RXEFile::dstocType elementType = programData->getTypeAtDSTOCIndex(dstocEntry + 1);
// Get dope vector
int32_t dopeVector = getScalarValue(dstocEntry);
if (arrayIndex >= SwapU16LittleToHost(dopeVectors[dopeVector].elementCount)) throw std::range_error("Array element not in range");
// Get size of an element.
unsigned size = SwapU16LittleToHost(dopeVectors[dopeVector].elementSize);
// Set element
setScalar(elementType, &(arrays[dopeVector][size*arrayIndex]), newValue);
}
void UnoAlarm::setFrequency(double frequencyHz) {
int f = 1;
// if we need a frequency >= system frequency, use scalar of 1
do {
double interuptFrequency = (systemFrequency / scalars[f].scalar);
if (frequencyHz < interuptFrequency) {
// so, now that we have more ticks than required, use counts to scale back further
break;
}
} while (scalars[f].scalar != 1);
double interuptFrequency = (systemFrequency / scalars[f].scalar);
unsigned int ticks = interuptFrequency / frequencyHz;
if (ticks > scalars[0].scalar) {
ticks = scalars[0].scalar;
}
setScalar(scalars[0].mask, scalars[f].mask);
setTicks(ticks);
}
void VertexScalar::loadScalars()
{
if (!mi) return;
SurfaceMesh *mesh = mi->getMesh();
if (!mesh) return;
unsigned int i = 0;
for (SurfaceMesh::VertexIter v_it = mesh->vertices_begin(); v_it!=mesh->vertices_end(); ++v_it) {
if (i >= ps->size()) {
ps->addParticle();
}
SurfaceMesh::TexCoord2D tc = mesh->texcoord2D(v_it);
setScalar(i,tc[0]);
i++;
}
for (unsigned int j = ps->size() - 1; j >= i; j--)
ps->removeParticle(j);
}
void ImageAccess::setVector(VectorXi position, Vector4f value) {
for(uchar i = 0; i < mImage->getNrOfComponents(); ++i) {
setScalar(position, value[i], i);
}
}
void VMMemory::setScalarValue(unsigned entry, int32_t newValue) throw(std::range_error, std::invalid_argument)
{
if (entry >= programData->getDSTOCCount()) throw std::range_error("Not a DSTOC entry");
RXEFile::dstocType type = programData->getTypeAtDSTOCIndex(entry);
setScalar(type, memory + programData->getDataDescriptorAtDSTOCIndex(entry), newValue);
}
void ImageAccess::setScalar(Vector2i position, float value, uchar channel) {
Vector3i position3D(position.x(), position.y(), 0);
setScalar(position3D, value, channel);
}
static __GLXconfig *
createModeFromConfig(const __DRIcoreExtension * core,
const __DRIconfig * driConfig,
unsigned int visualType, unsigned int drawableType)
{
__GLXDRIconfig *config;
GLint renderType = 0;
unsigned int attrib, value;
int i;
config = calloc(1, sizeof *config);
config->driConfig = driConfig;
i = 0;
while (core->indexConfigAttrib(driConfig, i++, &attrib, &value)) {
switch (attrib) {
case __DRI_ATTRIB_RENDER_TYPE:
if (value & __DRI_ATTRIB_RGBA_BIT)
renderType |= GLX_RGBA_BIT;
if (value & __DRI_ATTRIB_COLOR_INDEX_BIT)
renderType |= GLX_COLOR_INDEX_BIT;
#ifdef __DRI_ATTRIB_FLOAT_BIT
if (value & __DRI_ATTRIB_FLOAT_BIT)
renderType |= GLX_RGBA_FLOAT_BIT_ARB;
#endif
#ifdef __DRI_ATTRIB_UNSIGNED_FLOAT_BIT
if (value & __DRI_ATTRIB_UNSIGNED_FLOAT_BIT)
renderType |= GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT;
#endif
break;
case __DRI_ATTRIB_CONFIG_CAVEAT:
if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
config->config.visualRating = GLX_NON_CONFORMANT_CONFIG;
else if (value & __DRI_ATTRIB_SLOW_BIT)
config->config.visualRating = GLX_SLOW_CONFIG;
else
config->config.visualRating = GLX_NONE;
break;
case __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS:
config->config.bindToTextureTargets = 0;
if (value & __DRI_ATTRIB_TEXTURE_1D_BIT)
config->config.bindToTextureTargets |= GLX_TEXTURE_1D_BIT_EXT;
if (value & __DRI_ATTRIB_TEXTURE_2D_BIT)
config->config.bindToTextureTargets |= GLX_TEXTURE_2D_BIT_EXT;
if (value & __DRI_ATTRIB_TEXTURE_RECTANGLE_BIT)
config->config.bindToTextureTargets |=
GLX_TEXTURE_RECTANGLE_BIT_EXT;
break;
default:
setScalar(&config->config, attrib, value);
break;
}
}
config->config.next = NULL;
config->config.xRenderable = GL_TRUE;
config->config.visualType = visualType;
config->config.renderType = renderType;
config->config.drawableType = drawableType;
config->config.yInverted = GL_TRUE;
return &config->config;
}
static void
abv_init(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[], bool isStructInit)
{
int result;
char *bv_hostname = 0;
struct RDA_MessageStart *pMsgStart;
mxArray* OUT_STATE;
/* copy the params to the out state */
if(isStructInit) {
// init with struct
OUT_STATE = mxDuplicateArray(prhs[1]);
} else {
// init with property list
int dims[2] = {1,1};
OUT_STATE = mxCreateStructArray(2, dims, 0, NULL);
// arguments have beed checked in mexFunction
for(int i = 1; i < nrhs; i = i + 2) {
addField(OUT_STATE, prhs[i], prhs[i + 1]);
}
}
/* check for the needed fields values
* if they don't exist we will set the default values */
checkString(OUT_STATE,FIELD_HOST, "127.0.0.1");
/* Get server name (or use default "brainamp") */
bv_hostname = getString(OUT_STATE, FIELD_HOST);
/* open connection */
result = initConnection(bv_hostname,&pMsgStart);
free(bv_hostname);
if (result == IC_OKAY) {
/* construct connection state structure */
int nChans, lag, n;
double orig_fs;
mxArray *pArray;
char *pChannelName;
double *chan_sel;
double *filter_buffer_sub;
double *filter_buffer_a;
double *filter_buffer_b;
int iirFilterSize;
nChans = pMsgStart->nChannels;
orig_fs = 1000000.0 / ((double) pMsgStart->dSamplingInterval);
/* Check fs */
checkScalar(OUT_STATE,FIELD_FS,orig_fs);
lag = (int) (orig_fs / getScalar(OUT_STATE, FIELD_FS));
abv_assert(lag * (int)getScalar(OUT_STATE,FIELD_FS) == (int)orig_fs,"bbci_acquire_bv: The base frequency has to be a multiple of the requested frequency.");
/* Overwrite the following fields */
setScalar(OUT_STATE,FIELD_ORIG_FS, orig_fs);
setScalar(OUT_STATE,FIELD_LAG, lag);
setScalar(OUT_STATE,FIELD_BLOCK_NO, -1.0);
/* this odd hack is because pMsgStart contains several variably
sized arrays, and this is the way to get the channel names
*/
setStringCell(OUT_STATE, FIELD_CLAB,(char *) ((double*) pMsgStart->dResolutions + nChans), 1, nChans);
/* Check the following fields */
checkString(OUT_STATE,FIELD_MARKER_FORMAT, "numeric");
abv_assert(1 == checkScalar(OUT_STATE, FIELD_RECONNECT, 1), "bbci_acquire_bv: Reconnect is no scalar.");
abv_assert(1 == checkArray(OUT_STATE, FIELD_SCALE, 1, nChans, pMsgStart->dResolutions), "bbci_acquire_bv: Scale is no array or has wrong size.");
chan_sel = (double *) malloc(nChans*sizeof(double));
for (n = 0;n<nChans;n++) {
chan_sel[n] = n+1;
}
abv_assert(1 == checkArray(OUT_STATE, FIELD_CHAN_SEL, 1, -nChans, chan_sel), "bbci_acquire_bv: chan_sel is no array.");
free(chan_sel);
/* Create the default filters */
filter_buffer_sub = (double *) malloc(lag*sizeof(double));
for(n = 0; n < lag; ++n) {
filter_buffer_sub[n] = 1.0 / (double)lag;
}
filter_buffer_a = (double *) malloc(sizeof(double));
filter_buffer_a[0] = 1.0;
filter_buffer_b = (double *) malloc(sizeof(double));
filter_buffer_b[0] = 1.0;
/* check the filters */
abv_assert(1 == checkArray(OUT_STATE, FIELD_FILT_SUBSAMPLE, 1, lag, filter_buffer_sub), "bbci_acquire_bv: Subsample filter is no array or has the wrong size.");
abv_assert(1 == checkArray(OUT_STATE, FIELD_FILT_A, 1, -1, filter_buffer_a), "bbci_acquire_bv: IIR filter aSubsample filter has the wrong size.");
abv_assert(1 == checkArray(OUT_STATE, FIELD_FILT_B, 1, -1, filter_buffer_b), "bbci_acquire_bv: Subsample filter has the wrong size.");
/* free the default filters */
free(filter_buffer_sub);
free(filter_buffer_a);
free(filter_buffer_b);
/* check if the iir filters have the same size */
iirFilterSize = getArrayN(OUT_STATE, FIELD_FILT_A);
abv_assert(getArrayN(OUT_STATE, FIELD_FILT_B) == iirFilterSize, "bbci_acquire_bv: bFilter and aFilter must have the same size.");
/* get the arrays for the filters and create the filters */
filter_buffer_sub = getArray(OUT_STATE, FIELD_FILT_SUBSAMPLE);
filter_buffer_a = getArray(OUT_STATE, FIELD_FILT_A);
filter_buffer_b = getArray(OUT_STATE, FIELD_FILT_B);
filterFIRCreate(filter_buffer_sub, lag,nChans);
filterIIRCreate(filter_buffer_a, filter_buffer_b, iirFilterSize, nChans);
connected = 1;
}
plhs[0] = OUT_STATE;
free(pMsgStart);
}
