double calc_cv(double T, double r, double sigma, double epsilon, double m) {
double a = A(epsilon, sigma, r);
double b = B(epsilon, sigma, r);
vec3 q;
vec3 omega;
double W;
double cv = 0;
FILE *fp = fopen(QVEKT_FILE, "r");
if (!fp) {
perror("fopen");
exit(EXIT_FAILURE);
}
while(fscanf(fp, "%lg %lg %lg %lg", &q[X], &q[Y], &q[Z], &W) > 0) {
frequencies(a, b, m, q, omega, NULL);
scalar_mul(omega, HBAR/(KB*T));
cv += W * pow(omega[X], 2) * exp(omega[X]) * pow(exp(omega[X]) - 1, -2);
cv += W * pow(omega[Y], 2) * exp(omega[Y]) * pow(exp(omega[Y]) - 1, -2);
cv += W * pow(omega[Z], 2) * exp(omega[Z]) * pow(exp(omega[Z]) - 1, -2);
}
fclose(fp);
cv *= KB * 4.0e-3 * pow(r*sqrt(2), -3);
return cv;
}
void
BiquadFilterNode::GetFrequencyResponse(const Float32Array& aFrequencyHz,
const Float32Array& aMagResponse,
const Float32Array& aPhaseResponse)
{
aFrequencyHz.ComputeLengthAndData();
aMagResponse.ComputeLengthAndData();
aPhaseResponse.ComputeLengthAndData();
uint32_t length = std::min(std::min(aFrequencyHz.Length(), aMagResponse.Length()),
aPhaseResponse.Length());
if (!length) {
return;
}
nsAutoArrayPtr<float> frequencies(new float[length]);
float* frequencyHz = aFrequencyHz.Data();
const double nyquist = Context()->SampleRate() * 0.5;
// Normalize the frequencies
for (uint32_t i = 0; i < length; ++i) {
frequencies[i] = static_cast<float>(frequencyHz[i] / nyquist);
}
const double currentTime = Context()->CurrentTime();
double freq = mFrequency->GetValueAtTime(currentTime);
double q = mQ->GetValueAtTime(currentTime);
double gain = mGain->GetValueAtTime(currentTime);
double detune = mDetune->GetValueAtTime(currentTime);
WebCore::Biquad biquad;
SetParamsOnBiquad(biquad, Context()->SampleRate(), mType, freq, q, gain, detune);
biquad.getFrequencyResponse(int(length), frequencies, aMagResponse.Data(), aPhaseResponse.Data());
}
void UVImager::Image(class MeasurementSet &measurementSet, unsigned band)
{
unsigned frequencyCount = measurementSet.FrequencyCount();
IntegerDomain frequencies(0, frequencyCount);
_measurementSet = &measurementSet;
_band = _measurementSet->GetBandInfo(band);
Image(frequencies);
}
std::vector<size_t> readFrequencies(std::string const &inputFileName)
{
std::ifstream inputFile(inputFileName.c_str(), std::ifstream::binary | std::ifstream::in);
std::vector<size_t> frequencies((size_t)1 << CHAR_BIT * sizeof(unsigned char), 0);
char byte;
while (inputFile.get(byte)) {
frequencies[(unsigned char)byte]++;
}
return frequencies;
}
vector<double> gammatone::getCenterFrequencies(double beginFreq,
double endFreq,
int divideN ){
double beginERB = getERB( beginFreq );
double endERB = getERB( endFreq );
double space = (endERB - beginERB) / (divideN-1);
vector<double> frequencies(divideN);
for( int i=0;i<divideN;i++ ){
double erb = beginERB + i * space;
frequencies[i] = getFreq( erb );
/*
double freq = getFreq( erb );
double band = getERBand( freq );
*/
}
return frequencies;
}
static long Pitch_getMeanAbsoluteSlope (Pitch me,
double *out_hertz, double *out_mel, double *out_semitones, double *out_erb, double *out_withoutOctaveJumps)
{
long firstVoicedFrame = 0, lastVoicedFrame = 0, nVoiced = 0;
autoNUMvector <double> frequencies (1, my nx);
for (long i = 1; i <= my nx; i ++) {
double frequency = my frame [i]. candidate [1]. frequency;
frequencies [i] = frequency > 0.0 && frequency < my ceiling ? frequency : 0.0;
if (frequencies [i] != 0.0) nVoiced ++;
}
for (long i = 1; i <= my nx; i ++) // look for first voiced frame
if (frequencies [i] != 0.0) { firstVoicedFrame = i; break; }
for (long i = my nx; i >= 1; i --) // look for last voiced frame
if (frequencies [i] != 0.0) { lastVoicedFrame = i; break; }
if (nVoiced > 1) {
int ilast = firstVoicedFrame;
double span = (lastVoicedFrame - firstVoicedFrame) * my dx, flast = frequencies [ilast];
double slopeHz = 0.0, slopeMel = 0.0, slopeSemitones = 0.0, slopeErb = 0.0, slopeRobust = 0.0;
for (long i = firstVoicedFrame + 1; i <= lastVoicedFrame; i ++) if (frequencies [i] != 0.0) {
double localStepSemitones = fabs (SEMITONES (frequencies [i]) - SEMITONES (flast));
slopeHz += fabs (frequencies [i] - flast);
slopeMel += fabs (MEL (frequencies [i]) - MEL (flast));
slopeSemitones += localStepSemitones;
slopeErb += fabs (ERB (frequencies [i]) - ERB (flast));
while (localStepSemitones >= 12.0) localStepSemitones -= 12.0; // kill octave jumps
if (localStepSemitones > 6.0) localStepSemitones = 12.0 - localStepSemitones;
slopeRobust += localStepSemitones;
ilast = i;
flast = frequencies [ilast];
}
if (out_hertz) *out_hertz = slopeHz / span;
if (out_mel) *out_mel = slopeMel / span;
if (out_semitones) *out_semitones = slopeSemitones / span;
if (out_erb) *out_erb = slopeErb / span;
if (out_withoutOctaveJumps) *out_withoutOctaveJumps = slopeRobust / span;
} else {
if (out_hertz) *out_hertz = NUMundefined;
if (out_mel) *out_mel = NUMundefined;
if (out_semitones) *out_semitones = NUMundefined;
if (out_erb) *out_erb = NUMundefined;
if (out_withoutOctaveJumps) *out_withoutOctaveJumps = NUMundefined;
}
return nVoiced;
}
void calc_gamma(double *gamma, double *q, double delta, double r, double sigma, double epsilon, double m) {
const double V = pow(r, 3);
const double dV = pow(r + delta, 3) - pow(r - delta, 3);
double a, b;
vec3 omega[3];
double rnn = r - delta;
for (int i = 0; i < 3; i++) {
a = A(epsilon, sigma, rnn);
b = B(epsilon, sigma, rnn);
frequencies(a, b, m, q, omega[i], NULL);
rnn += delta;
}
gamma[X] = -V / omega[1][X] * (omega[2][X] - omega[0][X]) / dV;
gamma[Y] = -V / omega[1][Y] * (omega[2][Y] - omega[0][Y]) / dV;
gamma[Z] = -V / omega[1][Z] * (omega[2][Z] - omega[0][Z]) / dV;
}
void structPitch :: v_info () {
long nVoiced;
autoNUMvector <double> frequencies (Sampled_getSortedValues (this, Pitch_LEVEL_FREQUENCY, kPitch_unit_HERTZ, & nVoiced), 1);
structDaata :: v_info ();
MelderInfo_writeLine (U"Time domain:");
MelderInfo_writeLine (U" Start time: ", xmin, U" seconds");
MelderInfo_writeLine (U" End time: ", xmax, U" seconds");
MelderInfo_writeLine (U" Total duration: ", xmax - xmin, U" seconds");
MelderInfo_writeLine (U"Time sampling:");
MelderInfo_writeLine (U" Number of frames: ", nx, U" (", nVoiced, U" voiced)");
MelderInfo_writeLine (U" Time step: ", dx, U" seconds");
MelderInfo_writeLine (U" First frame centred at: ", x1, U" seconds");
MelderInfo_writeLine (U"Ceiling at: ", ceiling, U" Hz");
if (nVoiced >= 1) { // quantiles
double quantile10, quantile16, quantile50, quantile84, quantile90;
quantile10 = NUMquantile (nVoiced, frequencies.peek(), 0.10);
quantile16 = NUMquantile (nVoiced, frequencies.peek(), 0.16);
quantile50 = NUMquantile (nVoiced, frequencies.peek(), 0.50); // median
quantile84 = NUMquantile (nVoiced, frequencies.peek(), 0.84);
quantile90 = NUMquantile (nVoiced, frequencies.peek(), 0.90);
MelderInfo_writeLine (U"\nEstimated quantiles:");
MelderInfo_write (U" 10% = ", Melder_single (quantile10), U" Hz = ", Melder_single (MEL (quantile10)), U" Mel = ");
MelderInfo_writeLine (Melder_single (SEMITONES (quantile10)), U" semitones above 100 Hz = ", Melder_single (ERB (quantile10)), U" ERB");
MelderInfo_write (U" 16% = ", Melder_single (quantile16), U" Hz = ", Melder_single (MEL (quantile16)), U" Mel = ");
MelderInfo_writeLine (Melder_single (SEMITONES (quantile16)), U" semitones above 100 Hz = ", Melder_single (ERB (quantile16)), U" ERB");
MelderInfo_write (U" 50% = ", Melder_single (quantile50), U" Hz = ", Melder_single (MEL (quantile50)), U" Mel = ");
MelderInfo_writeLine (Melder_single (SEMITONES (quantile50)), U" semitones above 100 Hz = ", Melder_single (ERB (quantile50)), U" ERB");
MelderInfo_write (U" 84% = ", Melder_single (quantile84), U" Hz = ", Melder_single (MEL (quantile84)), U" Mel = ");
MelderInfo_writeLine (Melder_single (SEMITONES (quantile84)), U" semitones above 100 Hz = ", Melder_single (ERB (quantile84)), U" ERB");
MelderInfo_write (U" 90% = ", Melder_single (quantile90), U" Hz = ", Melder_single (MEL (quantile90)), U" Mel = ");
MelderInfo_writeLine (Melder_single (SEMITONES (quantile90)), U" semitones above 100 Hz = ", Melder_single (ERB (quantile90)), U" ERB");
if (nVoiced > 1) {
double corr = sqrt (nVoiced / (nVoiced - 1.0));
MelderInfo_writeLine (U"\nEstimated spreading:");
MelderInfo_write (U" 84%-median = ", Melder_half ((quantile84 - quantile50) * corr), U" Hz = ", Melder_half ((MEL (quantile84) - MEL (quantile50)) * corr), U" Mel = ");
MelderInfo_writeLine (Melder_half ((SEMITONES (quantile84) - SEMITONES (quantile50)) * corr), U" semitones = ", Melder_half ((ERB (quantile84) - ERB (quantile50)) * corr), U" ERB");
MelderInfo_write (U" median-16% = ", Melder_half ((quantile50 - quantile16) * corr), U" Hz = ", Melder_half ((MEL (quantile50) - MEL (quantile16)) * corr), U" Mel = ");
MelderInfo_writeLine (Melder_half ((SEMITONES (quantile50) - SEMITONES (quantile16)) * corr), U" semitones = ", Melder_half ((ERB (quantile50) - ERB (quantile16)) * corr), U" ERB");
MelderInfo_write (U" 90%-10% = ", Melder_half ((quantile90 - quantile10) * corr), U" Hz = ", Melder_half ((MEL (quantile90) - MEL (quantile10)) * corr), U" Mel = ");
MelderInfo_writeLine (Melder_half ((SEMITONES (quantile90) - SEMITONES (quantile10)) * corr), U" semitones = ", Melder_half ((ERB (quantile90) - ERB (quantile10)) * corr), U" ERB");
}
}
if (nVoiced >= 1) { // extrema, range, mean and standard deviation
double minimum = Pitch_getMinimum (this, xmin, xmax, kPitch_unit_HERTZ, false);
double maximum = Pitch_getMaximum (this, xmin, xmax, kPitch_unit_HERTZ, false);
double meanHertz, meanMel, meanSemitones, meanErb;
MelderInfo_write (U"\nMinimum ", Melder_single (minimum), U" Hz = ", Melder_single (MEL (minimum)), U" Mel = ");
MelderInfo_writeLine (Melder_single (SEMITONES (minimum)), U" semitones above 100 Hz = ", Melder_single (ERB (minimum)), U" ERB");
MelderInfo_write (U"Maximum ", Melder_single (maximum), U" Hz = ", Melder_single (MEL (maximum)), U" Mel = ");
MelderInfo_writeLine (Melder_single (SEMITONES (maximum)), U" semitones above 100 Hz = ", Melder_single (ERB (maximum)), U" ERB");
MelderInfo_write (U"Range ", Melder_half (maximum - minimum), U" Hz = ", Melder_single (MEL (maximum) - MEL (minimum)), U" Mel = ");
MelderInfo_writeLine (Melder_half (SEMITONES (maximum) - SEMITONES (minimum)), U" semitones = ", Melder_half (ERB (maximum) - ERB (minimum)), U" ERB");
meanHertz = Pitch_getMean (this, 0, 0, kPitch_unit_HERTZ);
meanMel = Pitch_getMean (this, 0, 0, kPitch_unit_MEL);
meanSemitones = Pitch_getMean (this, 0, 0, kPitch_unit_SEMITONES_100);
meanErb = Pitch_getMean (this, 0, 0, kPitch_unit_ERB);
MelderInfo_write (U"Average: ", Melder_single (meanHertz), U" Hz = ", Melder_single (meanMel), U" Mel = ");
MelderInfo_writeLine (Melder_single (meanSemitones), U" semitones above 100 Hz = ", Melder_single (meanErb), U" ERB");
if (nVoiced >= 2) {
double stdevHertz = Pitch_getStandardDeviation (this, 0, 0, kPitch_unit_HERTZ);
double stdevMel = Pitch_getStandardDeviation (this, 0, 0, kPitch_unit_MEL);
double stdevSemitones = Pitch_getStandardDeviation (this, 0, 0, kPitch_unit_SEMITONES_100);
double stdevErb = Pitch_getStandardDeviation (this, 0, 0, kPitch_unit_ERB);
MelderInfo_write (U"Standard deviation: ", Melder_half (stdevHertz), U" Hz = ", Melder_half (stdevMel), U" Mel = ");
MelderInfo_writeLine (Melder_half (stdevSemitones), U" semitones = ", Melder_half (stdevErb), U" ERB");
}
}
if (nVoiced > 1) { // variability: mean absolute slope
double slopeHertz, slopeMel, slopeSemitones, slopeErb, slopeWithoutOctaveJumps;
Pitch_getMeanAbsoluteSlope (this, & slopeHertz, & slopeMel, & slopeSemitones, & slopeErb, & slopeWithoutOctaveJumps);
MelderInfo_write (U"\nMean absolute slope: ", Melder_half (slopeHertz), U" Hz/s = ", Melder_half (slopeMel), U" Mel/s = ");
MelderInfo_writeLine (Melder_half (slopeSemitones), U" semitones/s = ", Melder_half (slopeErb), U" ERB/s");
MelderInfo_writeLine (U"Mean absolute slope without octave jumps: ", Melder_half (slopeWithoutOctaveJumps), U" semitones/s");
}
}
void
calc_fst (world_fmt * world, data_fmt * data)
{
long pop, locus;
long connections = world->numpop * (world->numpop - 1) / 2;
MYREAL ***fstfreq, *fw, *fb, *sumfb, *sumfw;
if (connections == 0)
return;
fw = (MYREAL *) mycalloc (1, sizeof (MYREAL) * world->numpop);
fb = (MYREAL *) mycalloc (1, sizeof (MYREAL) * connections);
sumfw = (MYREAL *) mycalloc (1, sizeof (MYREAL) * world->numpop);
sumfb = (MYREAL *) mycalloc (1, sizeof (MYREAL) * connections);
if (world->numpop > 2)
{
fst_type ('S');
}
fstfreq = (MYREAL ***) mycalloc (world->numpop, sizeof (MYREAL **));
for (pop = 0; pop < world->numpop; pop++)
{
doublevec2d(&fstfreq[pop],world->loci,255);
//fstfreq[pop] =
// (MYREAL **) mycalloc (world->loci, sizeof (MYREAL *));
//for (locus = 0; locus < world->loci; locus++)
// fstfreq[pop][locus] =
// (MYREAL *) mycalloc (255, sizeof (MYREAL));
}
if (!strchr (SEQUENCETYPES, world->options->datatype))
{
frequencies (fstfreq, data->yy, world->numpop, data->numind,
world->loci);
}
for (locus = 0; locus < world->loci; locus++)
{
if (strchr (SEQUENCETYPES, world->options->datatype))
{
calc_seq_fw (data, world->numpop, locus, fw);
calc_seq_fb (data, world->numpop, locus, fb);
}
else
{
calc_fw (fstfreq, world->numpop, locus, fw);
calc_fb (fstfreq, world->numpop, locus, fb);
}
(*solveNm) (fw, fb, world->numpop, world->fstparam[locus]);
for (pop = 0; pop < world->numpop; pop++)
{
sumfw[pop] += fw[pop];
}
for (pop = 0; pop < connections; pop++)
{
sumfb[pop] += fb[pop];
}
}
for (pop = 0; pop < world->numpop; pop++)
{
sumfw[pop] /= world->loci;
}
for (pop = 0; pop < connections; pop++)
{
sumfb[pop] /= world->loci;
}
if(world->loci > 1)
(*solveNm) (sumfw, sumfb, world->numpop, world->fstparam[world->loci]);
if (!strchr (SEQUENCETYPES, world->options->datatype))
{
for (pop = world->numpop; pop >= 0; pop++)
{
free_doublevec2d(fstfreq[pop]);
// for (locus = world->loci-1; locus >= 0; locus--)
// myfree(fstfreq[pop][locus]);
// myfree(fstfreq[pop]);
}
}
myfree(fstfreq);
myfree(fw);
myfree(fb);
myfree(sumfw);
myfree(sumfb);
}
/*
* Main entry point
*/
int main(int argc, char *argv[]) {
p = parseopts(argc, argv);
if (p == INVALID_PARAMETER) {
usage(EXIT_FAILURE);
}
int num_params = parseinput(argc, argv);
if (num_params == 0) {
usage(EXIT_FAILURE);
}
// Everything should be okay from here on
double sigma = MODEL_PARAMS[s].sigma;
double epsilon = MODEL_PARAMS[s].epsilon;
double m = MODEL_PARAMS[s].m;
double r = MODEL_PARAMS[s].r_nn;
if (p == OMEGA || p == GAMMA) {
vec3 dq = { 0, 0, 0 };
if (num_params == 2) {
dq[X] = (q2[X] - q1[X])/(npoints - 1);
dq[Y] = (q2[Y] - q1[Y])/(npoints - 1);
dq[Z] = (q2[Z] - q1[Z])/(npoints - 1);
}
if (p == OMEGA) {
vec3 omega;
double a = A(epsilon, sigma, r);
double b = B(epsilon, sigma, r);
if (num_params == 1) {
frequencies(a, b, m, q1, omega, NULL);
print_result(q1, omega);
}
else if (num_params == 2) {
for (int i = 0; i < npoints; i++) {
frequencies(a, b, m, q1, omega, NULL);
print_result(q1, omega);
q1[X] += dq[X];
q1[Y] += dq[Y];
q1[Z] += dq[Z];
}
}
}
else { // Gamma
vec3 gamma;
double delta = 1e-20;
if (num_params == 1) {
calc_gamma(gamma, q1, delta, r, sigma, epsilon, m);
print_result(q1, gamma);
}
else if (num_params == 2) {
for (int i = 0; i < npoints; i++) {
calc_gamma(gamma, q1, delta, r, sigma, epsilon, m);
print_result(q1, gamma);
q1[X] += dq[X];
q1[Y] += dq[Y];
q1[Z] += dq[Z];
}
}
}
}
else { // Cv
double cv;
if (num_params == 1) {
cv = calc_cv(t1, r, sigma, epsilon, m);
printf("%g %g\n", t1, cv);
}
else if (num_params == 2) {
double dt = (t2 - t1)/(npoints - 1);
for (int i = 0; i < npoints; i++) {
cv = calc_cv(t1, r, sigma, epsilon, m);
printf("%g %g\n", t1, cv);
t1 += dt;
}
}
}
return 0;
}
Layer::List Factory::toLayers(Data::Base& data)
{
Layer::List layers;
//qDebug() << "Layer::Factory converting" << Data::Type::toString(data.typeID());
try {
switch (data.typeID()) {
case Data::Type::Bank: {
Data::Bank& bank(dynamic_cast<Data::Bank&>(data));
layers << convert(bank);
} break;
case Data::Type::GeometryList: {
Data::GeometryList& list(dynamic_cast<Data::GeometryList&>(data));
layers << convert(list);
} break;
case Data::Type::Geometry: {
Data::Geometry& geometry(dynamic_cast<Data::Geometry&>(data));
layers << convert(geometry);
} break;
case Data::Type::PointChargeList: {
Data::PointChargeList& charges(dynamic_cast<Data::PointChargeList&>(data));
layers << convert(charges);
} break;
case Data::Type::MolecularOrbitalsList: {
Data::MolecularOrbitalsList& list(dynamic_cast<Data::MolecularOrbitalsList&>(data));
layers << convert(list);
} break;
case Data::Type::MolecularOrbitals: {
Data::MolecularOrbitals&
molecularOrbitals(dynamic_cast<Data::MolecularOrbitals&>(data));
layers.append(new MolecularOrbitals(molecularOrbitals));
} break;
case Data::Type::ExcitedStates: {
Data::ExcitedStates&
states(dynamic_cast<Data::ExcitedStates&>(data));
layers.append(new ExcitedStates(states));
} break;
case Data::Type::Frequencies: {
Data::Frequencies&
frequencies(dynamic_cast<Data::Frequencies&>(data));
layers.append(new Frequencies(frequencies));
} break;
case Data::Type::FileList: {
Data::FileList& fileList(dynamic_cast<Data::FileList&>(data));
layers << convert(fileList);
} break;
case Data::Type::GridData: {
QLOG_WARN() << "Data::GridData passed to LayerFactory";
//Data::GridData& grid(dynamic_cast<Data::GridData&>(data));
//layers.append(new CubeData(grid));
} break;
case Data::Type::CubeData: {
Data::CubeData& cube(dynamic_cast<Data::CubeData&>(data));
layers.append(new CubeData(cube));
} break;
case Data::Type::EfpFragment: {
Data::EfpFragment& efp(dynamic_cast<Data::EfpFragment&>(data));
layers.append(new EfpFragment(efp));
} break;
case Data::Type::EfpFragmentList: {
Data::EfpFragmentList&
efpList(dynamic_cast<Data::EfpFragmentList&>(data));
layers << convert(efpList);
} break;
case Data::Type::Mesh: {
Data::Mesh& meshData(dynamic_cast<Data::Mesh&>(data));
Data::Surface surface(meshData);
Layer::Surface* surfaceLayer(new Surface(surface));
surfaceLayer->setCheckState(Qt::Checked);
layers.append(surfaceLayer);
} break;
case Data::Type::Surface: {
Data::Surface& surfaceData(dynamic_cast<Data::Surface&>(data));
Layer::Surface* surfaceLayer(new Surface(surfaceData));
surfaceLayer->setCheckState(surfaceData.isVisible() ? Qt::Checked : Qt::Unchecked);
layers.append(surfaceLayer);
} break;
case Data::Type::Nmr: {
Data::Nmr& nmrData(dynamic_cast<Data::Nmr&>(data));
Layer::Nmr* nmrLayer(new Nmr(nmrData));
layers.append(nmrLayer);
} break;
default:
QLOG_WARN() << "Unimplemented data type in Layer::Factory"
<< Data::Type::toString(data.typeID());
break;
}
} catch (const std::bad_cast& e) {
QLOG_ERROR() << "Data cast in Layer::Factory failed"
<< Data::Type::toString(data.typeID());
}
return layers;
}
