c_interface_tools.cpp File Reference

#include <list>
#include <vector>
#include <algorithm>
#include <cmath>
#include <deque>
#include <fstream>
#include <iostream>
#include <limits>
#include <cfloat>
#include <assert.h>

Go to the source code of this file.

Data Structures
struct	Velocity

Macros
#define	_FCALL
#define	NDEBUG
#define	MY_REAL   double

Functions
bool	compareVel (Velocity a, Velocity b)
bool	areVelEqual (Velocity &a, Velocity &b)
void	globalVelocity (std::vector< Velocity > &v, MY_REAL &v1, MY_REAL &v2, MY_REAL &v3, int &freq)
void	c_compute_velocity_ (MY_REAL *v, int *numnod, int *idx, int *size_idx, MY_REAL *v1, int *freq)
void _FCALL	C_COMPUTE_VELOCITY (MY_REAL *v, int *numnod, int *idx, int *size_idx, MY_REAL *v1, int *freq)

Macro Definition Documentation

_FCALL

#define _FCALL

Definition at line 23 of file c_interface_tools.cpp.

MY_REAL

#define MY_REAL   double

Definition at line 42 of file c_interface_tools.cpp.

NDEBUG

#define NDEBUG

Definition at line 35 of file c_interface_tools.cpp.

Function Documentation

areVelEqual()

bool areVelEqual	(	Velocity &	a,
		Velocity &	b )

Definition at line 59 of file c_interface_tools.cpp.

{
    return (a.vx == b.vx && a.vy == b.vy && a.vz == b.vz);
}

C_COMPUTE_VELOCITY()

void _FCALL C_COMPUTE_VELOCITY	(	MY_REAL *	v,
		int *	numnod,
		int *	idx,
		int *	size_idx,
		MY_REAL *	v1,
		int *	freq )

Definition at line 145 of file c_interface_tools.cpp.

{
    c_compute_velocity_(v, numnod, idx, size_idx, v1, freq);
}

c_compute_velocity_()

void c_compute_velocity_	(	MY_REAL *	v,
		int *	numnod,
		int *	idx,
		int *	size_idx,
		MY_REAL *	v1,
		int *	freq )

Definition at line 123 of file c_interface_tools.cpp.

{
    std::vector<Velocity> vel;
    vel.resize(*size_idx);
    for(size_t i = 0; i < (size_t) *size_idx ; i++)
    {
                const int index_in_v = idx[i]-1;
        assert(index_in_v >= 0);
        assert(index_in_v < *numnod);
        vel[i].vx = v[3*index_in_v];
        vel[i].vy = v[3*index_in_v+1];
        vel[i].vz = v[3*index_in_v+2];
 
    }
        int f = 0;
    MY_REAL vx,vy,vz;
        globalVelocity(vel,vx,vy,vz,f);
    v1[0] = vx;
    v1[1] = vy;
    v1[2] = vz;
        *freq = f;
}

compareVel()

bool compareVel	(	Velocity	a,
		Velocity	b )

Definition at line 52 of file c_interface_tools.cpp.

{
    if(a.vx != b.vx) return (a.vx > b.vx);
    if(a.vy != b.vy) return (a.vy > b.vy);
    return (a.vz > b.vz);
}

globalVelocity()

void globalVelocity	(	std::vector< Velocity > &	v,
		MY_REAL &	v1,
		MY_REAL &	v2,
		MY_REAL &	v3,
		int &	freq )

Definition at line 73 of file c_interface_tools.cpp.

{
    std::sort(v.begin(),v.end(),compareVel);
    Velocity most_frequent_velocity;
    Velocity current_velocity;
    size_t max_frequency = 0;
    size_t current_frequency = 0;
 
    most_frequent_velocity.vx = FLT_MAX;
    most_frequent_velocity.vy = FLT_MAX;
    most_frequent_velocity.vz = FLT_MAX;
    current_velocity.vx = FLT_MAX;
    current_velocity.vy = FLT_MAX;
    current_velocity.vz = FLT_MAX;
 
    for(auto it = v.begin() ; it != v.end(); it++)
    {
        if(areVelEqual(current_velocity,*it))
        {
            current_frequency ++;
        }else
        { // new velocity
            if(max_frequency < current_frequency)
            { // save old velocity if it is the most frequent so far
                max_frequency = current_frequency;
                most_frequent_velocity.vx = current_velocity.vx;
                most_frequent_velocity.vy = current_velocity.vy;
                most_frequent_velocity.vz = current_velocity.vz;
            }
            current_frequency = 1;
            current_velocity.vx = (*it).vx;
            current_velocity.vy = (*it).vy;
            current_velocity.vz = (*it).vz;
        }
    }
 
    if(max_frequency < current_frequency)
    { // save old velocity if it is the most frequent so far
        max_frequency = current_frequency;
        most_frequent_velocity.vx = current_velocity.vx;
        most_frequent_velocity.vy = current_velocity.vy;
        most_frequent_velocity.vz = current_velocity.vz;
    }
    v1 = most_frequent_velocity.vx;
    v2 = most_frequent_velocity.vy;
    v3 = most_frequent_velocity.vz;
    freq = max_frequency;
}