// ****************************************************************************************************************************************************
double parOverlap(struct parSet* par1, int waveformVersion1, int injectionWF1, struct parSet* par2, int waveformVersion2, int injectionWF2, struct interferometer* ifo[], int ifonr, struct runPar run)
{
double overlap = 0.0;
fftw_complex *FFT1 = fftw_malloc(sizeof(fftw_complex) * (ifo[ifonr]->FTsize));
fftw_complex *FFT2 = fftw_malloc(sizeof(fftw_complex) * (ifo[ifonr]->FTsize));
// Get waveforms, FFT them and store them in FFT1,2
signalFFT(FFT1, par1, ifo, ifonr, waveformVersion1, injectionWF1, run);
signalFFT(FFT2, par2, ifo, ifonr, waveformVersion2, injectionWF2, run);
// Compute the overlap between the vectors FFT1,2, between index i1 and i2:
overlap = vecOverlap(FFT1, FFT2, ifo[ifonr]->noisePSD, ifo[ifonr]->lowIndex, ifo[ifonr]->highIndex, ifo[ifonr]->deltaFT);
fftw_free(FFT1);
fftw_free(FFT2);
return overlap;
} // End of parOverlap()
// ****************************************************************************************************************************************************
double overlapWithData(struct parSet *par, struct interferometer *ifo[], int ifonr, int waveformVersion, int injectionWF, struct runPar run)
{
fftw_complex *FFTwaveform = fftw_malloc(sizeof(fftw_complex) * (ifo[ifonr]->FTsize));
signalFFT(FFTwaveform, par, ifo, ifonr, waveformVersion, injectionWF, run);
double overlap = vecOverlap(ifo[ifonr]->raw_dataTrafo, FFTwaveform, ifo[ifonr]->noisePSD,
ifo[ifonr]->lowIndex, ifo[ifonr]->highIndex, ifo[ifonr]->deltaFT);
free(FFTwaveform);
return overlap;
} // End of overlapWithData()
// ****************************************************************************************************************************************************
double parMatch(struct parSet* par1, int waveformVersion1, int injectionWF1, struct parSet* par2, int waveformVersion2, int injectionWF2, struct interferometer *ifo[], int networkSize, struct runPar run)
{
double overlap11=0.0, overlap12=0.0, overlap22=0.0;
int ifonr;
fftw_complex *FFT1=NULL, *FFT2=NULL;
/*
printf(" parMatch: %i %i %i %i %i\n", waveformVersion1, injectionWF1, waveformVersion2, injectionWF2, networkSize);
int i=0;
for(i=0;i<12;i++) {
printf(" %i %f",i,par1->par[i]);
}
printf("\n");
for(i=0;i<12;i++) {
printf(" %i %f",i,par2->par[i]);
}
printf("\n");
*/
for(ifonr=0; ifonr<networkSize; ifonr++){
FFT1 = fftw_malloc(sizeof(fftw_complex) * (ifo[ifonr]->FTsize));
FFT2 = fftw_malloc(sizeof(fftw_complex) * (ifo[ifonr]->FTsize));
signalFFT(FFT1, par1, ifo, ifonr, waveformVersion1, injectionWF1, run);
signalFFT(FFT2, par2, ifo, ifonr, waveformVersion2, injectionWF2, run);
overlap11 += vecOverlap(FFT1, FFT1, ifo[ifonr]->noisePSD, ifo[ifonr]->lowIndex, ifo[ifonr]->highIndex, ifo[ifonr]->deltaFT);
overlap12 += vecOverlap(FFT1, FFT2, ifo[ifonr]->noisePSD, ifo[ifonr]->lowIndex, ifo[ifonr]->highIndex, ifo[ifonr]->deltaFT);
overlap22 += vecOverlap(FFT2, FFT2, ifo[ifonr]->noisePSD, ifo[ifonr]->lowIndex, ifo[ifonr]->highIndex, ifo[ifonr]->deltaFT);
}
double match = overlap12/sqrt(overlap11*overlap22);
free(FFT1);
free(FFT2);
return match;
} // End of parMatch()
vector<double> MatchParam::getParams(vector<cplx> signal, int numP,
int fi0PP, int stepDopler) {
vector<double> result(5);
int nUmp = periodRecordImp[numP];
// vector<vector<vector<vector<vector<double>>>>> fMMMP;
std::size_t signalLenght = signal.size();
vector<cplx> signalFFT(signalLenght, 0);
signalFFT = dft(signal);
vector<double> signalModule = absComplex(signalFFT);
int targetStep = (target.max - target.min)/target.numbPoints;
int clutterStep = (clutter.max - clutter.min)/clutter.numbPoints;
int widthClutterStep = widthClutter.max/widthClutter.numbPoints;
int amplStep = ampl.max/ampl.numbPoints;
double threshold = 2000;
std::size_t freqTarget = target.min;
#pragma omp parallel for
for (freqTarget = target.min; freqTarget < target.max; freqTarget += targetStep) {
std::cout << freqTarget << std::endl;
for (std::size_t freqClutter = clutter.min; freqClutter < clutter.max; freqClutter += clutterStep) {
for (std::size_t widClutter = widthClutter.min; widClutter < widthClutter.max;
widClutter += widthClutterStep) {
for (std::size_t aTarget = ampl.min; aTarget < ampl.max; aTarget += amplStep) {
for (std::size_t aClutter = ampl.min; aClutter < ampl.max; aClutter += amplStep) {
vector<cplx> bearingSignal(signalLenght);
std::size_t n = widClutter/widthClutterStep + 1;
double fd = 1200000/periodRecordImp[numP];
for (std::size_t i = 0; i < signalLenght; ++i) {
cplx clutt = cplx(0, 0);
double value = (1/fd) * i;
for (std::size_t j = 0; j < n; ++j) {
double freqClutterI = freqClutter - widClutter/2 + widthClutterStep * j;
clutt += cplx(aClutter, 0) * std::exp(cplx(0, 1) * freqClutterI);
}
bearingSignal[i] = cplx(aTarget, 0) * std::exp(cplx(0, 1) * cplx(freqTarget, 0) * cplx(value, 0)) + clutt * cplx(value, 0);
}
vector<cplx> bearingSpectr = dft(bearingSignal);
vector<double> bearingModule = absComplex(bearingSpectr);
vector<double> diff = difference(signalModule, bearingModule);
double error = 0;
for (auto const& value: diff) {
error += value;
}
if (abs(error) < threshold) {
threshold = abs(error);
result[0] = freqTarget;
result[1] = freqClutter;
result[2] = widClutter;
result[3] = aTarget;
result[4] = aClutter;
}
}
}
}
}
}
return result;
}
