RealVector realVector( double x0, double x1, double x2 )
{
RealVector result;
result.push_back( x0 );
result.push_back( x1 );
result.push_back( x2 );
return result;
}
RealVector realVector( double x0, double x1, double x2, double x3, double x4, double x5 )
{
RealVector result;
result.push_back( x0 );
result.push_back( x1 );
result.push_back( x2 );
result.push_back( x3 );
result.push_back( x4 );
result.push_back( x5 );
return result;
}
double evaluator(RealVector &v) {
RealVector obj;
for (int i = 0; i < 3; i++) {
obj.push_back(5.0);
}
return v.distance(obj);
}
int main(int argc, char **argv) {
RealVector up;
RealVector low;
RealVector sp;
double r0 = 0.1;
double phi0 = 0.9;
double population = 100;
double iterations = 100;
ArgumentData arg(argc, argv);
if ( arg.isOption("r0") ) {
arg.getOption("r0", r0);
}
if ( arg.isOption("phi0") ) {
arg.getOption("phi0", phi0);
}
if ( arg.isOption("population") ) {
arg.getOption("population", population);
}
if ( arg.isOption("iterations") ) {
arg.getOption("iterations", iterations);
}
for (int i = 0; i < 3; i++) {
up.push_back(10.0);
low.push_back(0.0);
sp.push_back(1.0);
}
boost::function1<double, RealVector> evalu(&evaluator);
ParticleSwarm p ( population, iterations, up, low, sp, evalu , r0, phi0);
std::cout << "Last population: " << p.populationToString() << endl;
std::cout << "Result: " << p.toString()<< std::endl;
return 0;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// devFundamentalFreqFinder
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void DevSuite::devFundamentalFreqFinder()
{
Logger msg( "devFundamentalFreqFinder" );
msg << Msg::Info << "Running devFundamentalFreqFinder..." << Msg::EndReq;
RandomNumberGenerator rng( 1 );
double pDetect = 0.8;
double baseFreq = 100;
double freqBlur = 5;
gPlotFactory().createPlot( "Toy model of detected Fourier frequencies" );
RealVector frequencies;
for ( size_t i = 1; i < 40; ++i )
{
bool isDetect = rng.uniform() < pDetect;
if ( !isDetect )
{
continue;
}
double freq = i * baseFreq + rng.uniform( -freqBlur, freqBlur );
frequencies.push_back( freq );
msg << Msg::Info << "Frequency: " << freq << Msg::EndReq;
gPlotFactory().createGraph( realVector( freq, freq ), realVector( 0, 1 ) );
}
Math::ApproximateGcdAlgorithm gcdAlg( 50 );
Math::ApproximateGcdAlgorithm::Result result = gcdAlg.execute( frequencies );
msg << Msg::Info << "Basefrequency = " << result.gcd << Msg::EndReq;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// studyTwinPeakPerformance
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AnalysisSrpa::studyTwinPeakPerformance( const std::vector< double >& frequencies, const std::vector< double >& frequencyDifference, double amp2 )
{
Synthesizer::SineGenerator generator1( m_samplingInfo );
Synthesizer::SineGenerator generator2( m_samplingInfo );
FeatureAlgorithm::SrSpecPeakAlgorithm peakAlg( 0.25, "PeakAlg", this );
WaveAnalysis::SpectralReassignmentTransform transform( m_samplingInfo, m_fourierSize, m_zeroPadSize, 1 );
generator1.setAmplitude( m_amplitude );
generator2.setAmplitude( amp2 );
Math::RegularAccumArray statusHist( 3, -0.5, NumHistStatusItems - 0.5 );
/// Loop over frequencies.
for ( size_t iFreq = 0; iFreq < frequencies.size(); ++iFreq )
{
double frequency = frequencies[ iFreq ];
generator1.setFrequency( frequency );
RawPcmData::Ptr data1 = generator1.generate( m_fourierSize );
RealVector freqDiffX;
RealVector freqDiffYMin;
RealVector freqDiffYMax;
/// Loop over frequency differences.
for ( size_t iFreqDiff = 0; iFreqDiff < frequencyDifference.size(); ++iFreqDiff )
{
double frequency2 = generator1.getFrequency() + frequencyDifference[ iFreqDiff ];
generator2.setFrequency( frequency2 );
RawPcmData::Ptr data2 = generator2.generate( m_fourierSize );
RawPcmData data( *data1 );
data.mixAdd( *data2 );
WaveAnalysis::StftData::Ptr stftData = transform.execute( data );
const WaveAnalysis::SrSpectrum& spectrum = stftData->getSrSpectrum( 0 );
FeatureAlgorithm::SrSpecPeakAlgorithm::Monitor* monitor = 0;
if ( iFreq == 0 && iFreqDiff == 2 )
{
monitor = new FeatureAlgorithm::SrSpecPeakAlgorithm::Monitor();
}
const std::vector< Feature::SrSpecPeak >& peaks = peakAlg.execute( spectrum, monitor );
if ( monitor )
{
monitor->createSpectrumPlot( getName() + "/FreqProx/FreqMonitor" );
delete monitor;
}
getLogger() << Msg::Info << "----------------------------------------" << Msg::EndReq;
getLogger() << Msg::Info << "iFreq = " << iFreq << ", iFreqDiff = " << iFreqDiff << Msg::EndReq;
getLogger() << Msg::Info << "Truth sinusoid 1: frequency = " << generator1.getFrequency() << ", amplitude = " << generator1.getAmplitude() << Msg::EndReq;
getLogger() << Msg::Info << "Truth sinusoid 2: frequency = " << generator2.getFrequency() << ", amplitude = " << generator2.getAmplitude() << Msg::EndReq;
RealVector peakAmps( peaks.size() );
for ( size_t iPeak = 0; iPeak < peaks.size(); ++iPeak )
{
peakAmps[ iPeak ] = peaks[ iPeak ].getHeight();
}
SortCache peakAmpsSc( peakAmps );
if ( peakAmpsSc.getSize() >= 2 )
{
double freqEstimate1 = peaks[ peakAmpsSc.getReverseSortedIndex( 0 ) ].getFrequency();
double freqEstimate2 = peaks[ peakAmpsSc.getReverseSortedIndex( 1 ) ].getFrequency();
double errDf1;
double errDf2;
int estimate1 = 2;
int estimate2 = 2;
if ( fabs( freqEstimate1 - frequency ) < fabs( freqEstimate1 - frequency2 ) )
{
estimate1 = 1;
errDf1 = freqEstimate1 - frequency;
errDf2 = freqEstimate2 - frequency2;
}
if ( fabs( freqEstimate2 - frequency ) < fabs( freqEstimate2 - frequency2 ) )
{
estimate2 = 1;
errDf1 = freqEstimate2 - frequency;
errDf2 = freqEstimate1 - frequency2;
}
if ( estimate1 != estimate2 )
{
statusHist.add( PeaksCorrect, 1 );
freqDiffX.push_back( frequencyDifference[ iFreqDiff ] );
freqDiffYMin.push_back( std::min( errDf1, errDf2 ) );
freqDiffYMax.push_back( std::max( errDf1, errDf2 ) );
}
else
{
statusHist.add( PeaksIncorrect, 1 );
}
}
else
{
statusHist.add( NotEnoughPeaks, 1 );
}
for ( size_t iPeak = 0; iPeak < peaks.size(); ++iPeak )
{
double recoAmp = peaks[ iPeak ].getHeight() / m_fourierSize;
getLogger() << Msg::Info << "Peak " << iPeak << ": frequency = " << peaks[ iPeak ].getFrequency() << ", amplitude " << recoAmp << Msg::EndReq;
}
} /// Loop over frequency differences.
std::ostringstream plotTitleFreqDifMin;
plotTitleFreqDifMin << getName() + "/FreqProx/FreqError" << frequency;
gPlotFactory().createPlot( plotTitleFreqDifMin.str() );
gPlotFactory().createGraph( freqDiffX, freqDiffYMin, Qt::blue );
gPlotFactory().createGraph( freqDiffX, freqDiffYMax, Qt::red );
} /// Loop over frequencies.
gPlotFactory().createPlot( getName() + "/FroxProx/CategorisedCounts" );
gPlotFactory().createHistogram( statusHist );
}
void GreensFunction3DRadInf::makeRnTable(RealVector& RnTable,
Real r, Real t) const
{
RnTable.clear();
const Real sigma(getSigma());
const Real D(getD());
const Real kf(getkf());
{
// First, estimate the size of p_corr, and if it's small enough,
// we don't need to calculate it in the first place.
const Real pirr(p_irr(r, t, r0, kf, D, sigma));
const Real ipfree_max(ip_free(M_PI, r, t) * 2 * M_PI * r * r);
if(fabs((pirr - ipfree_max) / ipfree_max) < 1e-8)
{
return;
}
}
const Real pfreemax(p_free_max(r, r0, t, D));
gsl_integration_workspace*
workspace(gsl_integration_workspace_alloc(2000));
Real Rn_prev(0.0);
const Real RnFactor(1.0 / (4.0 * M_PI * sqrt(r * r0)));
const Real integrationTolerance(pfreemax / RnFactor * THETA_TOLERANCE);
const Real truncationTolerance(pfreemax * THETA_TOLERANCE * 1e-1);
unsigned int n(0);
for (;;)
{
const Real Rn(this->Rn(n, r, t, workspace,
integrationTolerance));
RnTable.push_back(Rn);
// truncate when converged enough.
const Real absRn(fabs(Rn));
if(absRn * RnFactor < truncationTolerance &&
absRn < Rn_prev)
{
break;
}
if(n >= this->MAX_ORDER)
{
log_.info("GreensFunction3DRadInf: Rn didn't converge");
break;
}
Rn_prev = fabs(Rn);
++n;
}
gsl_integration_workspace_free(workspace);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// realVector
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RealVector realVector( double x0 )
{
RealVector result;
result.push_back( x0 );
return result;
}