int udp_marker_rec_get_bytes(struct my_data_t *my_data) {
int n_all=0,n=0;
my_data->co_new_data = 0;
while (true) {
n = recv(my_data->socket_id, my_data->cbuf, 1500, 0);
if (n==VISU_DATA_LENGTH) { /* receiving data with correct length */
# ifdef DEBUG
printf("Correct packet received.\n");
# endif
memcpy(&my_data->header, my_data->cbuf, HEADERSIZE);
unsigned int k = HEADERSIZE;
for (unsigned int i = 0; i < SEGMENTNUMBER; i++) {
memcpy(&my_data->Data[i], &my_data->cbuf[k + i * DATASIZE], DATASIZE);
}
for (unsigned int p = 0; p < SEGMENTNUMBER; p++) {
if (n==VISU_DATA_LENGTH) {
/* x, y, and z position coordinates*/
my_data->co_marker_data[p*7] = (double)(little2big(my_data->Data[p].Xcoord1,my_data->Data[p].Xcoord2,my_data->Data[p].Xcoord3,my_data->Data[p].Xcoord4));
my_data->co_marker_data[p*7+1] = (double)(little2big(my_data->Data[p].Ycoord1,my_data->Data[p].Ycoord2,my_data->Data[p].Ycoord3,my_data->Data[p].Ycoord4));
my_data->co_marker_data[p*7+2] = (double)(little2big(my_data->Data[p].Zcoord1,my_data->Data[p].Zcoord2,my_data->Data[p].Zcoord3,my_data->Data[p].Zcoord4));
/* quaternion data */
my_data->co_marker_data[p*7+3] = (double)(little2big(my_data->Data[p].Qre1,my_data->Data[p].Qre2,my_data->Data[p].Qre3,my_data->Data[p].Qre4));
my_data->co_marker_data[p*7+4] = (double)(little2big(my_data->Data[p].Qi1,my_data->Data[p].Qi2,my_data->Data[p].Qi3,my_data->Data[p].Qi4));
my_data->co_marker_data[p*7+5] = (double)(little2big(my_data->Data[p].Qj1,my_data->Data[p].Qj2,my_data->Data[p].Qj3,my_data->Data[p].Qj4));
my_data->co_marker_data[p*7+6] = (double)(little2big(my_data->Data[p].Qk1,my_data->Data[p].Qk2,my_data->Data[p].Qk3,my_data->Data[p].Qk4));
}
}
my_data->co_new_data = 1;
break;
} else {
# ifdef DEBUG
# ifdef WIN32
printf("Return of recv(): %ld\n", n );
printf("Error at recv(): %ld\n", WSAGetLastError() );
# endif
# endif
break;
}
}
return n_all;
}
int StVKReducedInternalForces::LoadFromStream(FILE * fin, int rTarget, int bigEndianMachine)
{
if (verbose)
printf("Loading polynomials assuming little endian machine: %s.", (!bigEndianMachine) ? "TRUE" : "FALSE");
int header[4];
if ((int)(fread(header, sizeof(int), 4, fin)) < 4)
{
printf("Error: couldn't read from input cubic polynomial file.\n");
throw 1;
}
r = header[0];
int buffer;
if (bigEndianMachine)
{
little2big(&r, &buffer, sizeof(int));
r = buffer;
}
if (rTarget > r)
{
printf("Error: the input cubic polynomial file has r=%d, but you requested %d > %d.\n", r, rTarget, r);
throw 2;
}
// first read in the coefficients as if all modes requested
if (verbose)
printf(" r=%d\n", r);
r2 = r * r;
linearSize = header[1];
if (bigEndianMachine)
{
little2big(&linearSize, &buffer, sizeof(int));
linearSize = buffer;
}
quadraticSize = header[2];
if (bigEndianMachine)
{
little2big(&quadraticSize, &buffer, sizeof(int));
quadraticSize = buffer;
}
cubicSize = header[3];
if (bigEndianMachine)
{
little2big(&cubicSize, &buffer, sizeof(int));
cubicSize = buffer;
}
linearCoef_ = (double*) malloc (sizeof(double) * r * linearSize);
if ((int)(fread(linearCoef_,sizeof(double),r*linearSize,fin)) < r*linearSize)
{
printf("Error: couldn't read from input cubic polynomial file.\n");
throw 1;
}
double bufferd;
if (bigEndianMachine)
{
for(int i=0; i<r*linearSize; i++)
{
little2big(&linearCoef_[i], &bufferd, sizeof(double));
linearCoef_[i] = bufferd;
}
}
quadraticCoef_ = (double*) malloc (sizeof(double) * r * quadraticSize);
if ((int)(fread(quadraticCoef_,sizeof(double),r*quadraticSize,fin)) < r*quadraticSize)
{
printf("Error: couldn't read from input cubic polynomial file.\n");
throw 1;
}
if (bigEndianMachine)
{
for(int i=0; i<r*quadraticSize; i++)
{
little2big(&quadraticCoef_[i], &bufferd, sizeof(double));
quadraticCoef_[i] = bufferd;
}
}
cubicCoef_ = (double*) malloc (sizeof(double) * r * cubicSize);
if ((int)(fread(cubicCoef_,sizeof(double),r*cubicSize,fin)) < r*cubicSize)
{
printf("Error: couldn't read from input cubic polynomial file.\n");
throw 1;
}
if (bigEndianMachine)
{
for(int i=0; i<r*cubicSize; i++)
{
little2big(&cubicCoef_[i], &bufferd, sizeof(double));
cubicCoef_[i] = bufferd;
}
}
if (rTarget >= 0)
{
int linearSizeTarget, quadraticSizeTarget, cubicSizeTarget;
GetSizes(rTarget, &linearSizeTarget, &quadraticSizeTarget, &cubicSizeTarget);
double * linearCoefTemp_ =
(double*) malloc (sizeof(double) * rTarget * linearSizeTarget);
double * quadraticCoefTemp_ =
(double*) malloc (sizeof(double) * rTarget * quadraticSizeTarget);
double * cubicCoefTemp_ =
(double*) malloc (sizeof(double) * rTarget * cubicSizeTarget);
for(int output=0; output<rTarget; output++)
for(int i=0; i<rTarget; i++)
{
SetSizes(rTarget);
int positionTarget = linearCoefPos(output, i);
SetSizes(r);
int position = linearCoefPos(output, i);
linearCoefTemp_[positionTarget] = linearCoef_[position];
}
for(int output=0; output<rTarget; output++)
for(int i=0; i<rTarget; i++)
for(int j=i; j<rTarget; j++)
{
SetSizes(rTarget);
int positionTarget = quadraticCoefPos(output, i, j);
SetSizes(r);
int position = quadraticCoefPos(output, i, j);
quadraticCoefTemp_[positionTarget] = quadraticCoef_[position];
}
for(int output=0; output<rTarget; output++)
for(int i=0; i<rTarget; i++)
for(int j=i; j<rTarget; j++)
for(int k=j; k<rTarget; k++)
{
SetSizes(rTarget);
int positionTarget = cubicCoefPos(output, i, j, k);
SetSizes(r);
int position = cubicCoefPos(output, i, j, k);
cubicCoefTemp_[positionTarget] = cubicCoef_[position];
}
r = rTarget;
SetSizes(r);
free(linearCoef_);
free(quadraticCoef_);
free(cubicCoef_);
linearCoef_ = linearCoefTemp_;
quadraticCoef_ = quadraticCoefTemp_;
cubicCoef_ = cubicCoefTemp_;
}
volumetricMesh = NULL;
U = NULL;
reducedGravityForce = NULL;
precomputedIntegrals = NULL;
numElementVertices = 0;
muLame = NULL;
InitBuffers();
addGravity = false;
useSingleThread = 0;
shallowCopy = 0;
g=9.81;
return 0;
}
