sunwen/UR
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Remove temperature dependensy.

Browse Source
This commit is contained in:
sunwen
2025-03-14 15:28:18 +08:00
parent 577294088b
commit 3db427dc6b
18 changed files with 321 additions and 332 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
src/common/getMeasurementMetaData.cpp
View File

@@ -6,6 +6,7 @@
#include "Function.h" #include "Function.h"
#include "Function2D.h" #include "Function2D.h"
#include "Matrix.h"
#include "Parser.h" #include "Parser.h"
#include "Data/MetaData.h" #include "Data/MetaData.h"
#include "Data/MovementData.h" #include "Data/MovementData.h"
@@ -16,6 +17,7 @@
#include "ceMatchedFilterHandling.h" #include "ceMatchedFilterHandling.h"
#include "ShotList/ShotList.h" #include "ShotList/ShotList.h"
#include "config/config.h" #include "config/config.h"
#include "temperatureCalculation/estimateSOSWater.h"
using namespace Recon; using namespace Recon;
@@ -148,110 +150,10 @@ Matrix Recon::temperatureToSoundSpeed(const Matrix& aTemperature, const std::str
} }
//已验证，完全正确 //已验证，完全正确
TempInfo Recon::getTemperatureInfo(Parser* aParser, float aNumTas) TempInfo Recon::getTemperatureInfo(Parser* aParser, const CEInfo& aCEInfo)
{ {
TempInfo result; TempInfo result;
//jumoTemp result.expectedSOSWater = estimateSOSWater(aParser,aCEInfo);
JumoTemperaturePointer jumoTemp1 = aParser->getTemperatureData().getJumoTemperature1();
JumoTemperaturePointer jumoTemp2 = aParser->getTemperatureData().getJumoTemperature1();
JumoTemperaturePointer jumoTemp3 = aParser->getTemperatureData().getJumoTemperature1();
JumoTemperaturePointer jumoTemp4 = aParser->getTemperatureData().getJumoTemperature1();
int jumoTempNum = jumoTemp1.getLength();
if(jumoTemp2.getLength() < jumoTempNum)
{
jumoTempNum = jumoTemp2.getLength();
}
if(jumoTemp3.getLength() < jumoTempNum)
{
jumoTempNum = jumoTemp3.getLength();
}
if(jumoTemp4.getLength() < jumoTempNum)
{
jumoTempNum = jumoTemp4.getLength();
}
float* jumoTempData = Aurora::malloc(jumoTempNum * 4);
for(int i=0; i<jumoTempNum; ++i)
{
jumoTempData[4*i] = jumoTemp1.get()[i];
jumoTempData[4*i + 1] = jumoTemp2.get()[i];
jumoTempData[4*i + 2] = jumoTemp3.get()[i];
jumoTempData[4*i + 3] = jumoTemp4.get()[i];
}
result.jumoTemp = Aurora::Matrix::New(jumoTempData, 4, jumoTempNum);//输出
bool tasTempUsed = false;
//Tas Temperature
if(reconParams::useTASTempComp)
{
//todo TemperatureModel4D字段不存在
// try
// % load temp from files.tempTASComp (standard file, including the preprocessed/corrected temperature data)
// % and extract infos, TemperatureModel4D and TASTemperature
// TASTemp = loadTASTemperaturesProcessed(path, files.tempTASComp);
// % extract TemperatureModel4D
// if isfield(TASTemp, 'TemperatureModel4D')
// temp.TemperatureModel4D = TASTemp.TemperatureModel4D;
// end
// % extract TASTemperatures
// temp.TASTemperature = TASTemp.TASTemperature;
// catch
// tasTempCompUsed = 0;
// end
}
if (!tasTempUsed)
{
size_t tasTempLength = aParser->getTemperatureData().getTasTemperature()[0].getLength();
float* fromTasTempData = aParser->getTemperatureData().getTasTemperature()[0].get();
float* tasTempData = new float[tasTempLength];
std::copy(fromTasTempData, fromTasTempData+ tasTempLength, tasTempData);
Matrix tasTemp = Matrix::fromRawData(tasTempData, 2, tasTempLength / 2);
if (!reconParams::correctTASTemp || result.jumoTemp.isNan())
{
result.tasTemperature = tasTemp;
}
else
{
//todo JumoTemp都没有值
// temp.TASTemperature(1, :, :) = correctTASTemperatures(temp2, temp.jumoTemp);
// catch ME
// % if tas temperatures not there
// % take temperatures from calibrated sensors
// % and use them for all TAS the same
// writeReconstructionLog(sprintf('%s: %s TAS temperatures approximated from calibrated reference sensors.', ME.identifier, ME.message), 3)
// if(~jumoAllNaN)
// temp.TASTemperature = zeros(2, numTAS, size(temp.jumoTemp, 2));
// temp.TASTemperature(1, :, :) = repmat(mean(temp.jumoTemp), size(temp.TASTemperature, 2), 1);
// temp.TASTemperature(2, :, :) = repmat([1:size(temp.TASTemperature, 2)]', 1, size(temp.TASTemperature, 3));
// else % worst case: no temperature data at all! cannot continue!
// error([mfilename ':noTemperatureAvailable'],'No TAS and no Jumo temperature available! Cannot reconstruct!');
// end
// end
}
}
if (result.jumoTemp.isNan())
{
result.expectedTemp = mean(result.tasTemperature(0,$,$).toMatrix(),FunctionDirection::Column,false);
result.jumoTemp = result.expectedTemp;
}
else
{
result.expectedTemp = mean(result.jumoTemp,FunctionDirection::All,false);
}
result.expectedSOSWater = temperatureToSoundSpeed(result.expectedTemp , "marczak");
return result; return result;
} }

5
src/common/getMeasurementMetaData.h
View File

@@ -44,9 +44,6 @@ namespace Recon
struct TempInfo struct TempInfo
{ {
Aurora::Matrix jumoTemp;
Aurora::Matrix tasTemperature;
Aurora::Matrix expectedTemp;
Aurora::Matrix expectedSOSWater; Aurora::Matrix expectedSOSWater;
}; };
@@ -72,7 +69,7 @@ namespace Recon
Aurora::Matrix getAvailableMotorPositions(Parser* aParser); Aurora::Matrix getAvailableMotorPositions(Parser* aParser);
MeasurementInfo loadMeasurementInfos(Parser* aParser); MeasurementInfo loadMeasurementInfos(Parser* aParser);
TransFormInfo getTransformationMatrix(Parser* aParser, const Aurora::Matrix& aMotorPosList); TransFormInfo getTransformationMatrix(Parser* aParser, const Aurora::Matrix& aMotorPosList);
TempInfo getTemperatureInfo(Parser* aParser, float aNumTas); TempInfo getTemperatureInfo(Parser* aParser, const CEInfo& aCEInfo);
CEInfo getCEInfo(Parser* aParser, const MeasurementInfo aInfo); CEInfo getCEInfo(Parser* aParser, const MeasurementInfo aInfo);
Aurora::Matrix temperatureToSoundSpeed(const Aurora::Matrix& aTemperature, const std::string& aMethod); Aurora::Matrix temperatureToSoundSpeed(const Aurora::Matrix& aTemperature, const std::string& aMethod);

102
src/common/temperatureCalculation/estimateSOSWater.cpp Normal file
View File

@@ -0,0 +1,102 @@
#include "estimateSOSWater.h"
#include "Function1D.cuh"
#include "Function1D.h"
#include "Matrix.h"
#include "CudaMatrix.h"
#include "common/dataBlockCreation/getAscanBlock.h"
#include "transmissionReconstruction/detection/getTransmissionData.cuh"
#include "transmissionReconstruction/detection/detection.h"
#include "config/config.h"
#include "config/geometryConfig.h"
#include "Function2D.cuh"
#include "Function2D.h"
#include "common/dataBlockCreation/getAscanBlock.h"
#include <cstring>
using namespace Recon;
namespace
{
const Aurora::Matrix EMIT_TAS = Aurora::Matrix::fromRawData(new float[17]{94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110}, 17);
const Aurora::Matrix RECEIVE_TAS = Aurora::Matrix::fromRawData(new float[17]{103, 104, 105, 106, 107, 108, 109, 110, 94, 95, 96, 97, 98, 99, 100, 101, 102}, 17);
const Aurora::Matrix ALL_RECEIVER_TAS_LIST = Aurora::Matrix::fromRawData(new float[128] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128},128); //1~128
const Aurora::Matrix ALL_RECEIVER_ELEMENT_LIST = Aurora::Matrix::fromRawData(new float[18] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18},18);
const float SOS_INITIAL = 1509.3;
const float THRE = 0.5;
inline int findIndexFromEmitterAndReceiver(const Aurora::Matrix& aEmitter, float aEmitterValue, const Aurora::Matrix& aReceiver, float aReceiverValue)
{
for (int i = 0; i < aEmitter.getDataSize(); ++i)
{
if (aEmitter[i] == aEmitterValue && aReceiver[i] == aReceiverValue)
{
return i;
}
}
return -1;
}
Aurora::Matrix matchFilt(const Aurora::CudaMatrix& aSig, const Aurora::CudaMatrix& aMod)
{
Aurora::CudaMatrix fftMod = fft(aMod);
Aurora::CudaMatrix fftSig = fft(aSig);
Aurora::CudaMatrix mfFftSig = getTransmissionDataSubFunction(fftSig, fftMod);
Aurora::Matrix mfSig = Aurora::real(ifft(mfFftSig)).toHostMatrix();
std::memmove(mfSig.getData(), mfSig.getData() + 1, (mfSig.getDataSize() - 1) * sizeof(float));
return mfSig;
}
inline int findFirstvalueGreaterThanGivenValue(const Aurora::Matrix& aMatrix, float aValue)
{
for(int i=0; i<aMatrix.getDataSize(); ++i)
{
if(aMatrix[i] > aValue)
{
return i;
}
}
return -1;
}
}
Aurora::Matrix Recon::estimateSOSWater(Parser *aParser, const CEInfo &aCE)
{
int offset = transParams::priorWvOffset;
int rn = 18;
int emitterSize = EMIT_TAS.getDataSize();
Aurora::Matrix distance = Aurora::Matrix::fromRawData(new float[emitterSize]{0}, emitterSize);
Aurora::Matrix mp = Aurora::Matrix::fromRawData(new float[1]{1}, 1);
Aurora::Matrix sn = Aurora::Matrix::fromRawData(new float[1]{18}, 1);
Aurora::Matrix tof = Aurora::Matrix::fromRawData(new float[emitterSize], 1, emitterSize);
float snValue = 18;
#pragma omp parallel for
for(int i=0; i<emitterSize; ++i)
{
Aurora::Matrix sl = Aurora::Matrix::fromRawData(new float[1]{EMIT_TAS[i]}, 1);
float slValue = EMIT_TAS[i];
float rl = RECEIVE_TAS[i];
Aurora::Matrix positionOfEmitter = emitterPositions[slValue-1](snValue-1).toMatrix();
Aurora::Matrix positionOfReceiver = emitterPositions[rl-1](rn-1).toMatrix();
distance[i] = Aurora::norm(positionOfEmitter - positionOfReceiver, Aurora::Norm2);
AscanBlock ascan = getAscanBlock(aParser, mp, sl, sn, ALL_RECEIVER_TAS_LIST, ALL_RECEIVER_ELEMENT_LIST);
size_t dataSize = ascan.ascanBlock.getDataSize();
short* data = new short[dataSize];
std::copy(ascan.ascanBlock.getData(), ascan.ascanBlock.getData() + dataSize, data);
Aurora::Matrix rf = Aurora::convertfp16tofloat(data, ascan.ascanBlock.getDimSize(0), ascan.ascanBlock.getDimSize(1));
delete[] data;
Aurora::CudaMatrix rfDevice = rf.toDeviceMatrix() / ascan.gainBlock.toDeviceMatrix();
int rfIndex = findIndexFromEmitterAndReceiver(aCE.tasIndices, rl, aCE.receiverIndices, rn);
rfDevice = rfDevice.block(1, rfIndex, rfIndex);
Aurora::Matrix rfMf = matchFilt(rfDevice, aCE.ceRef.toDeviceMatrix());
Aurora::Matrix rfWin = applyTimeWindowing(rfMf, transParams::aScanReconstructionFrequency, distance(i).toMatrix(), SOS_INITIAL,
transParams::offsetElectronic * transParams::aScanReconstructionFrequency, transParams::detectionWindowSOS,
transParams::minSpeedOfSound, transParams::maxSpeedOfSound, transParams::gaussWindow).AscanBlockProcessed;
Aurora::Matrix rfEnv = abs(Aurora::hilbert(rfWin));
Aurora::Matrix rfNorm = rfEnv / max(rfEnv);
tof[i] = findFirstvalueGreaterThanGivenValue(rfNorm, THRE) + 1;
}
tof = (tof + offset) / transParams::aScanReconstructionFrequency;
auto sos = mean(distance / tof);
return sos;
}

14
src/common/temperatureCalculation/estimateSOSWater.h Normal file
View File

@@ -0,0 +1,14 @@
#ifndef ESTIMATE_SOS_WATER_H
#define ESTIMATE_SOS_WATER_H
#include "Matrix.h"
#include "common/getMeasurementMetaData.h"
class Parser;
namespace Recon
{
Aurora::Matrix estimateSOSWater(Parser* aParser, const CEInfo& aCE);
}
#endif

5
src/config/config.cpp
View File

@@ -559,6 +559,10 @@ namespace Recon
{ {
transParams::detectionWindowATT = detection.at("detectionWindowATT").get<int>(); transParams::detectionWindowATT = detection.at("detectionWindowATT").get<int>();
} }
if(detection.contains("priorWvOffset"))
{
transParams::priorWvOffset = detection.at("priorWvOffset").get<int>();
}
} }
if(params.contains("rayTracing")) if(params.contains("rayTracing"))
@@ -748,6 +752,7 @@ namespace Recon
transParams::detectionWindowATT = 50; transParams::detectionWindowATT = 50;
transParams::pulseLengthSamples = 0; transParams::pulseLengthSamples = 0;
transParams::pulseLengthRefSamples = 0; transParams::pulseLengthRefSamples = 0;
transParams::priorWvOffset = -3;
//transParams.rayTracing //transParams.rayTracing
transParams::bentReconstruction = false; transParams::bentReconstruction = false;
transParams::bresenham = 1; transParams::bresenham = 1;

1
src/config/config.h
View File

@@ -146,6 +146,7 @@ namespace Recon
EXTERN_C int detectionWindowATT; EXTERN_C int detectionWindowATT;
EXTERN_C float pulseLengthSamples; EXTERN_C float pulseLengthSamples;
EXTERN_C float pulseLengthRefSamples; EXTERN_C float pulseLengthRefSamples;
EXTERN_C int priorWvOffset;
//transParams.rayTracing //transParams.rayTracing
EXTERN_C bool bentReconstruction; EXTERN_C bool bentReconstruction;
EXTERN_C int bresenham; EXTERN_C int bresenham;

4
src/startReconstructions.cpp
View File

@@ -83,8 +83,8 @@ int Recon::startReconstructions( const std::string& aDataPath, const std::string
//getMeasurementMetaData //getMeasurementMetaData
float maxNumTAS = max(auroraUnion(slList, rlList)).getData()[0]; float maxNumTAS = max(auroraUnion(slList, rlList)).getData()[0];
MeasurementInfo expInfo = loadMeasurementInfos(&dataParser); MeasurementInfo expInfo = loadMeasurementInfos(&dataParser);
TempInfo temp = getTemperatureInfo(&dataParser, maxNumTAS);
CEInfo ce = getCEInfo(&dataParser, expInfo); CEInfo ce = getCEInfo(&dataParser, expInfo);
TempInfo temp = getTemperatureInfo(&dataParser, ce);
TransFormInfo transformationInfo = getTransformationMatrix(&dataParser, motorPosTotal); TransFormInfo transformationInfo = getTransformationMatrix(&dataParser, motorPosTotal);
Matrix transformationMatrices = transformationInfo.rotationMatrix; Matrix transformationMatrices = transformationInfo.rotationMatrix;
Matrix motorPosAvailable = transformationInfo.motorPos; Matrix motorPosAvailable = transformationInfo.motorPos;
@@ -97,8 +97,8 @@ int Recon::startReconstructions( const std::string& aDataPath, const std::string
if(transParams::runTransmissionReco) if(transParams::runTransmissionReco)
{ {
expInfoRef = loadMeasurementInfos(&refParser); expInfoRef = loadMeasurementInfos(&refParser);
tempRef = getTemperatureInfo(&refParser, maxNumTAS);
ceRef = getCEInfo(&refParser, expInfoRef); ceRef = getCEInfo(&refParser, expInfoRef);
tempRef = getTemperatureInfo(&refParser, ceRef);
transformationInfo = getTransformationMatrix(&refParser, motorPosTotal); transformationInfo = getTransformationMatrix(&refParser, motorPosTotal);
transformationMatricesRef = transformationInfo.rotationMatrix; transformationMatricesRef = transformationInfo.rotationMatrix;
motorPosAvailableRef = transformationInfo.motorPos; motorPosAvailableRef = transformationInfo.motorPos;

5
src/transmissionReconstruction/dataFilter/dataFilter.cpp
View File

@@ -75,7 +75,7 @@ namespace Recon {
} }
checkTofDetectionsResult checkTofDetections(const Aurora::Matrix &aVTofValues, const Aurora::Matrix &aVDists, checkTofDetectionsResult checkTofDetections(const Aurora::Matrix &aVTofValues, const Aurora::Matrix &aVDists,
const Aurora::Matrix &aVSosRef, float aVSosRef,
float minSpeedOfSound, float minSpeedOfSound,
float maxSpeedOfSound) float maxSpeedOfSound)
{ {
@@ -122,11 +122,10 @@ namespace Recon {
for (size_t i = 0; i < aVSNRList.getDataSize(); i++) for (size_t i = 0; i < aVSNRList.getDataSize(); i++)
{ {
if (finite_SNRList.getData()[i] == 1.0){ if (finite_SNRList.getData()[i] == 1.0){
meanSNR+=aVSNRList[i];
std_SNRListData[j++] = aVSNRList[i]; std_SNRListData[j++] = aVSNRList[i];
} }
} }
meanSNR = meanSNR/(float)j; meanSNR = mean(aVSNRList)[0];
Aurora::Matrix std_SNRList = Aurora::Matrix::New(std_SNRListData,count,1,1); Aurora::Matrix std_SNRList = Aurora::Matrix::New(std_SNRListData,count,1,1);
std_SNRList = Aurora::std(std_SNRList); std_SNRList = Aurora::std(std_SNRList);
float localSNRDifference = 2 * std_SNRList.getScalar(); float localSNRDifference = 2 * std_SNRList.getScalar();

2
src/transmissionReconstruction/dataFilter/dataFilter.h
View File

@@ -27,7 +27,7 @@ struct checkTofDetectionsResult
checkTofDetectionsResult checkTofDetections(const Aurora::Matrix &aVTofValues, checkTofDetectionsResult checkTofDetections(const Aurora::Matrix &aVTofValues,
const Aurora::Matrix &aVDists, const Aurora::Matrix &aVDists,
const Aurora::Matrix &aVSosRef, float aVSosRef,
float minSpeedOfSound, float minSpeedOfSound,
float maxSpeedOfSound); float maxSpeedOfSound);
/** /**

54
src/transmissionReconstruction/detection/detection.cpp
View File

@@ -8,6 +8,7 @@
#include "Function2D.h" #include "Function2D.h"
#include "Function3D.h" #include "Function3D.h"
#include "Matrix.h"
#include "common/getMeasurementMetaData.h" #include "common/getMeasurementMetaData.h"
#include "config/config.h" #include "config/config.h"
#include "transmissionReconstruction/detection/detection.cuh" #include "transmissionReconstruction/detection/detection.cuh"
@@ -81,19 +82,18 @@ namespace Recon {
} }
TimeWindowResult applyTimeWindowing(const Aurora::Matrix &AscanBlock, float sampleRate, TimeWindowResult applyTimeWindowing(const Aurora::Matrix &AscanBlock, float sampleRate,
const Aurora::Matrix &distBlock, const Aurora::Matrix &sosBlock, const Aurora::Matrix &distBlock, float sosWater,
float expectedSOSWater, float startOffset, float segmentLenOffset, float startOffset, float segmentLenOffset,
float minSpeedOfSound, float maxSpeedOfSound, bool gaussWindow) float minSpeedOfSound, float maxSpeedOfSound, bool gaussWindow)
{ {
auto sosOffset = calculateSOSOffset(sosBlock, expectedSOSWater, distBlock, sampleRate); Aurora::Matrix sosOffset = Aurora::Matrix::fromRawData(new float[1]{0}, 1);
auto calcResult = calculateStarEndSearchPosition(distBlock, minSpeedOfSound, maxSpeedOfSound, sampleRate,AscanBlock.getDimSize(0), sosOffset, startOffset, segmentLenOffset); auto calcResult = calculateStarEndSearchPosition(distBlock, minSpeedOfSound, maxSpeedOfSound, sampleRate,AscanBlock.getDimSize(0), sosOffset, startOffset, segmentLenOffset);
auto AscanBlockProcessed = zeros(AscanBlock.getDimSize(0),AscanBlock.getDimSize(1)); auto AscanBlockProcessed = zeros(AscanBlock.getDimSize(0),AscanBlock.getDimSize(1));
if(gaussWindow) if(gaussWindow)
{ {
auto expectedPosWater = (distBlock / expectedSOSWater) * sampleRate + startOffset; auto expectedPosWater = (distBlock / sosWater) * sampleRate + startOffset;
auto windowWidth = calcResult.endSearch-calcResult.startSearch; auto windowWidth = calcResult.endSearch-calcResult.startSearch;
#pragma omp parallel for #pragma omp parallel for
for (size_t i = 0; i < AscanBlock.getDimSize(1); i++) for (size_t i = 0; i < AscanBlock.getDimSize(1); i++)
@@ -132,7 +132,7 @@ namespace Recon {
Aurora::Matrix detectAttVectorized(const Aurora::Matrix &Ascan, const Aurora::Matrix &AscanRef, Aurora::Matrix detectAttVectorized(const Aurora::Matrix &Ascan, const Aurora::Matrix &AscanRef,
const Aurora::Matrix &distRef, const Aurora::Matrix &distRef,
const Aurora::Matrix &sosWaterRef, float sosWaterRef,
const Aurora::Matrix &tof, int aScanReconstructionFrequency, const Aurora::Matrix &tof, int aScanReconstructionFrequency,
float offsetElectronic, int detectionWindowATT) float offsetElectronic, int detectionWindowATT)
{ {
@@ -173,8 +173,7 @@ namespace Recon {
DetectResult detectTofVectorized( DetectResult detectTofVectorized(
const Aurora::Matrix &AscanBlock, const Aurora::Matrix &AscanRefBlock, const Aurora::Matrix &AscanBlock, const Aurora::Matrix &AscanRefBlock,
const Aurora::Matrix &distBlock, const Aurora::Matrix &distBlockRef, const Aurora::Matrix &distBlock, const Aurora::Matrix &distBlockRef,
const Aurora::Matrix &sosWaterBlock, float aSOSWater, float aSOSWaterRef,
const Aurora::Matrix &sosWaterRefBlock, float expectedSOSWater,
int useTimeWindowing, int aScanReconstructionFrequency, int useTimeWindowing, int aScanReconstructionFrequency,
float offsetElectronic, int detectionWindowSOS, float minSpeedOfSound, float offsetElectronic, int detectionWindowSOS, float minSpeedOfSound,
float maxSpeedOfSound, bool gaussWindow) float maxSpeedOfSound, bool gaussWindow)
@@ -188,12 +187,12 @@ namespace Recon {
timeResult2.AscanBlockProcessed = AscanRefBlock; timeResult2.AscanBlockProcessed = AscanRefBlock;
if (useTimeWindowing == 1) { if (useTimeWindowing == 1) {
timeResult1 = applyTimeWindowing( timeResult1 = applyTimeWindowing(
AscanBlock, sampleRate, distBlock, sosWaterBlock, AscanBlock, sampleRate, distBlock,
expectedSOSWater, offsetElectronicSamples, detectionWindowSOS, aSOSWater, offsetElectronicSamples, detectionWindowSOS,
minSpeedOfSound, maxSpeedOfSound, gaussWindow); minSpeedOfSound, maxSpeedOfSound, gaussWindow);
timeResult2 = applyTimeWindowing( timeResult2 = applyTimeWindowing(
AscanRefBlock, sampleRate, distBlockRef, sosWaterRefBlock, AscanRefBlock, sampleRate, distBlockRef,
expectedSOSWater, offsetElectronicSamples, detectionWindowSOS, aSOSWaterRef, offsetElectronicSamples, detectionWindowSOS,
minSpeedOfSound, maxSpeedOfSound, gaussWindow); minSpeedOfSound, maxSpeedOfSound, gaussWindow);
diffStartSearch = timeResult1.startSearch - timeResult2.startSearch; diffStartSearch = timeResult1.startSearch - timeResult2.startSearch;
@@ -234,7 +233,7 @@ namespace Recon {
if (useTimeWindowing) { if (useTimeWindowing) {
shiftInSamples = shiftInSamples - diffStartSearch; shiftInSamples = shiftInSamples - diffStartSearch;
} }
auto tof = shiftInSamples / sampleRate + distBlock / sosWaterBlock; auto tof = shiftInSamples / sampleRate + distBlock / aSOSWater;
auto sosValue = distBlock / tof; auto sosValue = distBlock / tof;
DetectResult result; DetectResult result;
result.tof = tof; result.tof = tof;
@@ -245,9 +244,7 @@ namespace Recon {
DetectResult detectTofAndAtt( DetectResult detectTofAndAtt(
const Aurora::Matrix &AscanBlock, const Aurora::Matrix &AscanRefBlock, const Aurora::Matrix &AscanBlock, const Aurora::Matrix &AscanRefBlock,
const Aurora::Matrix &distBlock, const Aurora::Matrix &distRefBlock, const Aurora::Matrix &distBlock, const Aurora::Matrix &distRefBlock,
const Aurora::Matrix &sosWaterBlock, int resampleFactor,int nthreads, float aSOSWater, float aSOSWaterRef,
const Aurora::Matrix &sosWaterRefBlock,
int resampleFactor,int nthreads, float expectedSOSWater,
int useTimeWindowing, int aScanReconstructionFrequency,int detectionWindowATT, int useTimeWindowing, int aScanReconstructionFrequency,int detectionWindowATT,
float offsetElectronic, int detectionWindowSOS, float minSpeedOfSound, float offsetElectronic, int detectionWindowSOS, float minSpeedOfSound,
float maxSpeedOfSound, bool gaussWindow) float maxSpeedOfSound, bool gaussWindow)
@@ -261,12 +258,12 @@ namespace Recon {
timeResult2.AscanBlockProcessed = AscanRefBlock; timeResult2.AscanBlockProcessed = AscanRefBlock;
if (useTimeWindowing == 1) { if (useTimeWindowing == 1) {
timeResult1 = applyTimeWindowing( timeResult1 = applyTimeWindowing(
AscanBlock, sampleRate, distBlock, sosWaterBlock, AscanBlock, sampleRate, distBlock,
expectedSOSWater, offsetElectronicSamples, detectionWindowSOS, aSOSWater, offsetElectronicSamples, detectionWindowSOS,
minSpeedOfSound, maxSpeedOfSound, gaussWindow); minSpeedOfSound, maxSpeedOfSound, gaussWindow);
timeResult2 = applyTimeWindowing( timeResult2 = applyTimeWindowing(
AscanRefBlock, sampleRate, distRefBlock, sosWaterRefBlock, AscanRefBlock, sampleRate, distRefBlock,
expectedSOSWater, offsetElectronicSamples, detectionWindowSOS, aSOSWaterRef, offsetElectronicSamples, detectionWindowSOS,
minSpeedOfSound, maxSpeedOfSound, gaussWindow); minSpeedOfSound, maxSpeedOfSound, gaussWindow);
diffStartSearch = timeResult1.startSearch - timeResult2.startSearch; diffStartSearch = timeResult1.startSearch - timeResult2.startSearch;
@@ -307,13 +304,13 @@ namespace Recon {
if (useTimeWindowing) { if (useTimeWindowing) {
shiftInSamples = shiftInSamples - diffStartSearch; shiftInSamples = shiftInSamples - diffStartSearch;
} }
auto tof = shiftInSamples / sampleRate + distBlock / sosWaterBlock; auto tof = shiftInSamples / sampleRate + distBlock / aSOSWater;
auto sosValue = distBlock / tof; auto sosValue = distBlock / tof;
DetectResult result; DetectResult result;
result.sosValue = sosValue; result.sosValue = sosValue;
auto tofRel = tof - distBlock / sosWaterBlock; auto tofRel = tof - distBlock / aSOSWater;
result.att = detectAttVectorized( result.att = detectAttVectorized(
_AscanBlock, _AscanRefBlock, distRefBlock, sosWaterRefBlock, _AscanBlock, _AscanRefBlock, distRefBlock, aSOSWaterRef,
tof, aScanReconstructionFrequency, offsetElectronic, tof, aScanReconstructionFrequency, offsetElectronic,
detectionWindowATT); detectionWindowATT);
result.tof = tofRel; result.tof = tofRel;
@@ -423,11 +420,8 @@ namespace Recon {
const Aurora::CudaMatrix &AscanRefBlock, const Aurora::CudaMatrix &AscanRefBlock,
const Aurora::CudaMatrix &distBlock, const Aurora::CudaMatrix &distBlock,
const Aurora::CudaMatrix &distRefBlock, const Aurora::CudaMatrix &distRefBlock,
const Aurora::Matrix &sosWaterBlock, float aSOSWater, float aSOSWaterRef)
const Aurora::Matrix &sosWaterRefBlock, {
float expectedSOSWater) {
auto _sosWaterBlock = temperatureToSoundSpeed(sosWaterBlock, "marczak").toDeviceMatrix();
auto _sosWaterRefBlock = temperatureToSoundSpeed(sosWaterRefBlock, "marczak").toDeviceMatrix();
switch (Recon::transParams::version) { switch (Recon::transParams::version) {
// case 1: { // case 1: {
// return detectTofAndAttMex( // return detectTofAndAttMex(
@@ -442,8 +436,8 @@ namespace Recon {
default: default:
auto r = detectTofAndAtt( auto r = detectTofAndAtt(
AscanBlock, AscanRefBlock, distBlock, distRefBlock, AscanBlock, AscanRefBlock, distBlock, distRefBlock,
_sosWaterBlock, _sosWaterRefBlock, Recon::transParams::resampleFactor, Recon::transParams::nThreads, Recon::transParams::resampleFactor, Recon::transParams::nThreads,
expectedSOSWater, Recon::transParams::useTimeWindowing, aSOSWater, aSOSWaterRef, Recon::transParams::useTimeWindowing,
Recon::transParams::aScanReconstructionFrequency, Recon::transParams::detectionWindowATT, Recon::transParams::aScanReconstructionFrequency, Recon::transParams::detectionWindowATT,
Recon::transParams::offsetElectronic, Recon::transParams::detectionWindowSOS, Recon::transParams::minSpeedOfSound, Recon::transParams::offsetElectronic, Recon::transParams::detectionWindowSOS, Recon::transParams::minSpeedOfSound,
Recon::transParams::maxSpeedOfSound, Recon::transParams::gaussWindow); Recon::transParams::maxSpeedOfSound, Recon::transParams::gaussWindow);

33
src/transmissionReconstruction/detection/detection.cu
View File

@@ -66,7 +66,7 @@ CudaMatrix Recon::calculateAttenuationCuda(const CudaMatrix &ascans,
CudaMatrix CudaMatrix
Recon::detectAttVectorizedCuda(const CudaMatrix &Ascan, const CudaMatrix &AscanRef, Recon::detectAttVectorizedCuda(const CudaMatrix &Ascan, const CudaMatrix &AscanRef,
const CudaMatrix &distRef, const CudaMatrix &distRef,
const CudaMatrix &sosWaterRef, float sosWaterRef,
const CudaMatrix &tof, int aScanReconstructionFrequency, const CudaMatrix &tof, int aScanReconstructionFrequency,
float offsetElectronic, int detectionWindowATT) { float offsetElectronic, int detectionWindowATT) {
auto sizeAscan = size(Ascan); auto sizeAscan = size(Ascan);
@@ -169,19 +169,18 @@ __global__ void guassWindowKernel(float* aStartSearch,float* aEndSearch,
} }
Recon::TimeWindowResultC Recon::applyTimeWindowing(const Aurora::CudaMatrix &AscanBlock, float sampleRate, Recon::TimeWindowResultC Recon::applyTimeWindowing(const Aurora::CudaMatrix &AscanBlock, float sampleRate,
const Aurora::CudaMatrix &distBlock, const Aurora::CudaMatrix &sosBlock, const Aurora::CudaMatrix &distBlock,
float expectedSOSWater, float startOffset, float segmentLenOffset, float aSOSWater, float startOffset, float segmentLenOffset,
float minSpeedOfSound, float maxSpeedOfSound, bool gaussWindow) float minSpeedOfSound, float maxSpeedOfSound, bool gaussWindow)
{ {
auto sosOffset = calculateSOSOffset(sosBlock, expectedSOSWater, distBlock, sampleRate); Aurora::CudaMatrix sosOffset = Aurora::zerosCuda(1,1);
auto calcResult = calculateStarEndSearchPosition(distBlock, minSpeedOfSound, maxSpeedOfSound, sampleRate,AscanBlock.getDimSize(0), sosOffset, startOffset, segmentLenOffset); auto calcResult = calculateStarEndSearchPosition(distBlock, minSpeedOfSound, maxSpeedOfSound, sampleRate,AscanBlock.getDimSize(0), sosOffset, startOffset, segmentLenOffset);
auto AscanBlockProcessed = zerosCuda(AscanBlock.getDimSize(0),AscanBlock.getDimSize(1)); auto AscanBlockProcessed = zerosCuda(AscanBlock.getDimSize(0),AscanBlock.getDimSize(1));
if(gaussWindow) if(gaussWindow)
{ {
auto expectedPosWater = (distBlock / expectedSOSWater) * sampleRate + startOffset; auto expectedPosWater = (distBlock / aSOSWater) * sampleRate + startOffset;
guassWindowKernel<<<AscanBlock.getDimSize(1),256>>>(calcResult.startSearch.getData(), guassWindowKernel<<<AscanBlock.getDimSize(1),256>>>(calcResult.startSearch.getData(),
calcResult.endSearch.getData(), AscanBlock.getData(), AscanBlockProcessed.getData(), calcResult.endSearch.getData(), AscanBlock.getData(), AscanBlockProcessed.getData(),
expectedPosWater.getData(), AscanBlock.getDimSize(0)); expectedPosWater.getData(), AscanBlock.getDimSize(0));
@@ -253,9 +252,7 @@ int nextpow2(unsigned int value){
Recon::DetectResultC Recon::detectTofAndAtt( Recon::DetectResultC Recon::detectTofAndAtt(
const Aurora::CudaMatrix &AscanBlock, const Aurora::CudaMatrix &AscanRefBlock, const Aurora::CudaMatrix &AscanBlock, const Aurora::CudaMatrix &AscanRefBlock,
const Aurora::CudaMatrix &distBlock, const Aurora::CudaMatrix &distRefBlock, const Aurora::CudaMatrix &distBlock, const Aurora::CudaMatrix &distRefBlock,
const Aurora::CudaMatrix &sosWaterBlock, int resampleFactor,int nthreads, float aSOSWater, float aSOSWaterRef,
const Aurora::CudaMatrix &sosWaterRefBlock,
int resampleFactor,int nthreads, float expectedSOSWater,
int useTimeWindowing, int aScanReconstructionFrequency,int detectionWindowATT, int useTimeWindowing, int aScanReconstructionFrequency,int detectionWindowATT,
float offsetElectronic, int detectionWindowSOS, float minSpeedOfSound, float offsetElectronic, int detectionWindowSOS, float minSpeedOfSound,
float maxSpeedOfSound, bool gaussWindow) float maxSpeedOfSound, bool gaussWindow)
@@ -269,12 +266,12 @@ Recon::DetectResultC Recon::detectTofAndAtt(
timeResult2.AscanBlockProcessed = AscanRefBlock; timeResult2.AscanBlockProcessed = AscanRefBlock;
if (useTimeWindowing == 1) { if (useTimeWindowing == 1) {
timeResult1 = applyTimeWindowing( timeResult1 = applyTimeWindowing(
AscanBlock, sampleRate, distBlock, sosWaterBlock, AscanBlock, sampleRate, distBlock,
expectedSOSWater, offsetElectronicSamples, detectionWindowSOS, aSOSWater, offsetElectronicSamples, detectionWindowSOS,
minSpeedOfSound, maxSpeedOfSound, gaussWindow); minSpeedOfSound, maxSpeedOfSound, gaussWindow);
timeResult2 = applyTimeWindowing( timeResult2 = applyTimeWindowing(
AscanRefBlock, sampleRate, distRefBlock, sosWaterRefBlock, AscanRefBlock, sampleRate, distRefBlock,
expectedSOSWater, offsetElectronicSamples, detectionWindowSOS, aSOSWaterRef, offsetElectronicSamples, detectionWindowSOS,
minSpeedOfSound, maxSpeedOfSound, gaussWindow); minSpeedOfSound, maxSpeedOfSound, gaussWindow);
diffStartSearch = timeResult1.startSearch - timeResult2.startSearch; diffStartSearch = timeResult1.startSearch - timeResult2.startSearch;
@@ -296,8 +293,8 @@ Recon::DetectResultC Recon::detectTofAndAtt(
CudaMatrix c_1_1; CudaMatrix c_1_1;
{ {
auto x = fft(_AscanBlock, m2); auto x = fft(_AscanBlock, m2);
auto y = fft(_AscanRefBlock, m2); auto y = conj(fft(_AscanRefBlock, m2));
c_1_1 = x * conj(y); c_1_1 = x * y;
} }
c_1_2 = ifft(c_1_1); c_1_2 = ifft(c_1_1);
} }
@@ -313,13 +310,13 @@ Recon::DetectResultC Recon::detectTofAndAtt(
if (useTimeWindowing) { if (useTimeWindowing) {
shiftInSamples = shiftInSamples - diffStartSearch; shiftInSamples = shiftInSamples - diffStartSearch;
} }
auto tof = shiftInSamples / sampleRate + distBlock / sosWaterBlock; auto tof = shiftInSamples / sampleRate + distBlock / aSOSWater;
auto sosValue = distBlock / tof; auto sosValue = distBlock / tof;
Recon::DetectResultC result; Recon::DetectResultC result;
result.sosValue = sosValue; result.sosValue = sosValue;
auto tofRel = tof - distBlock / sosWaterBlock; auto tofRel = tof - distBlock / aSOSWater;
result.att = detectAttVectorizedCuda( result.att = detectAttVectorizedCuda(
_AscanBlock, _AscanRefBlock, distRefBlock, sosWaterRefBlock, _AscanBlock, _AscanRefBlock, distRefBlock, aSOSWaterRef,
tof, aScanReconstructionFrequency, offsetElectronic, tof, aScanReconstructionFrequency, offsetElectronic,
detectionWindowATT); detectionWindowATT);
result.tof = tofRel; result.tof = tofRel;

10
src/transmissionReconstruction/detection/detection.cuh
View File

@@ -25,13 +25,13 @@ struct TimeWindowResultC {
CudaMatrix CudaMatrix
detectAttVectorizedCuda(const CudaMatrix &Ascan, const CudaMatrix &AscanRef, detectAttVectorizedCuda(const CudaMatrix &Ascan, const CudaMatrix &AscanRef,
const CudaMatrix &distRef, const CudaMatrix &distRef,
const CudaMatrix &sosWaterRef, float sosWaterRef,
const CudaMatrix &tof, int aScanReconstructionFrequency, const CudaMatrix &tof, int aScanReconstructionFrequency,
float offsetElectronic, int detectionWindowATT); float offsetElectronic, int detectionWindowATT);
TimeWindowResultC applyTimeWindowing(const Aurora::CudaMatrix &AscanBlock, float sampleRate, TimeWindowResultC applyTimeWindowing(const Aurora::CudaMatrix &AscanBlock, float sampleRate,
const Aurora::CudaMatrix &distBlock, const Aurora::CudaMatrix &sosBlock, const Aurora::CudaMatrix &distBlock,
float expectedSOSWater, float startOffset, float segmentLenOffset, float aSOSWater, float startOffset, float segmentLenOffset,
float minSpeedOfSound, float maxSpeedOfSound, bool gaussWindow); float minSpeedOfSound, float maxSpeedOfSound, bool gaussWindow);
SearchPositionC calculateStarEndSearchPosition(const CudaMatrix &aVDistBlock, SearchPositionC calculateStarEndSearchPosition(const CudaMatrix &aVDistBlock,
float minSpeedOfSound, float maxSpeedOfSound, float minSpeedOfSound, float maxSpeedOfSound,
@@ -42,9 +42,7 @@ struct TimeWindowResultC {
DetectResultC detectTofAndAtt( DetectResultC detectTofAndAtt(
const Aurora::CudaMatrix &AscanBlock, const Aurora::CudaMatrix &AscanRefBlock, const Aurora::CudaMatrix &AscanBlock, const Aurora::CudaMatrix &AscanRefBlock,
const Aurora::CudaMatrix &distBlock, const Aurora::CudaMatrix &distRefBlock, const Aurora::CudaMatrix &distBlock, const Aurora::CudaMatrix &distRefBlock,
const Aurora::CudaMatrix &sosWaterBlock, int resampleFactor,int nthreads, float aSOSWater, float aSOSWaterRef,
const Aurora::CudaMatrix &sosWaterRefBlock,
int resampleFactor,int nthreads, float expectedSOSWater,
int useTimeWindowing, int aScanReconstructionFrequency,int detectionWindowATT, int useTimeWindowing, int aScanReconstructionFrequency,int detectionWindowATT,
float offsetElectronic, int detectionWindowSOS, float minSpeedOfSound, float offsetElectronic, int detectionWindowSOS, float minSpeedOfSound,
float maxSpeedOfSound, bool gaussWindow); float maxSpeedOfSound, bool gaussWindow);

14
src/transmissionReconstruction/detection/detection.h
View File

@@ -32,14 +32,14 @@ calculateStarEndSearchPosition(const Aurora::Matrix &aVDistBlock,
TimeWindowResult applyTimeWindowing( TimeWindowResult applyTimeWindowing(
const Aurora::Matrix &AscanBlock, float sampleRate, const Aurora::Matrix &AscanBlock, float sampleRate,
const Aurora::Matrix &distBlock, const Aurora::Matrix &sosBlock, const Aurora::Matrix &distBlock, float sosWater,
float expectedSOSWater, float startOffset, float segmentLenOffset, float startOffset, float segmentLenOffset,
float minSpeedOfSound, float maxSpeedOfSound, bool gaussWindow); float minSpeedOfSound, float maxSpeedOfSound, bool gaussWindow);
Aurora::Matrix Aurora::Matrix
detectAttVectorized(const Aurora::Matrix &Ascan, const Aurora::Matrix &AscanRef, detectAttVectorized(const Aurora::Matrix &Ascan, const Aurora::Matrix &AscanRef,
const Aurora::Matrix &distRef, const Aurora::Matrix &distRef,
const Aurora::Matrix &sosWaterRef, float sosWaterRef,
const Aurora::Matrix &tof, int aScanReconstructionFrequency, const Aurora::Matrix &tof, int aScanReconstructionFrequency,
float offsetElectronic, int detectionWindowATT); float offsetElectronic, int detectionWindowATT);
@@ -47,8 +47,7 @@ DetectResult
detectTofVectorized( detectTofVectorized(
const Aurora::Matrix &AscanBlock, const Aurora::Matrix &AscanRefBlock, const Aurora::Matrix &AscanBlock, const Aurora::Matrix &AscanRefBlock,
const Aurora::Matrix &distBlock, const Aurora::Matrix &distBlockRef, const Aurora::Matrix &distBlock, const Aurora::Matrix &distBlockRef,
const Aurora::Matrix &sosWaterBlock, float aSOSWater, float aSOSWaterRef,
const Aurora::Matrix &sosWaterRefBlock, float expectedSOSWater,
int useTimeWindowing, int aScanReconstructionFrequency, int useTimeWindowing, int aScanReconstructionFrequency,
float offsetElectronic, int detectionWindowSOS, float minSpeedOfSound, float offsetElectronic, int detectionWindowSOS, float minSpeedOfSound,
float maxSpeedOfSound, bool gaussWindow); float maxSpeedOfSound, bool gaussWindow);
@@ -57,8 +56,7 @@ DetectResult
detectTofAndAtt( detectTofAndAtt(
const Aurora::Matrix &AscanBlock, const Aurora::Matrix &AscanRefBlock, const Aurora::Matrix &AscanBlock, const Aurora::Matrix &AscanRefBlock,
const Aurora::Matrix &distBlock, const Aurora::Matrix &distRefBlock, const Aurora::Matrix &distBlock, const Aurora::Matrix &distRefBlock,
const Aurora::Matrix &sosWaterBlock, const Aurora::Matrix &sosWaterRefBlock, int resampleFactor, int nthreads, float aSOSWater, float aSOSWaterRef,
int resampleFactor, int nthreads, float expectedSOSWater,
int useTimeWindowing, int aScanReconstructionFrequency, int useTimeWindowing, int aScanReconstructionFrequency,
int detectionWindowATT, float offsetElectronic, int detectionWindowSOS, int detectionWindowATT, float offsetElectronic, int detectionWindowSOS,
float minSpeedOfSound, float maxSpeedOfSound, bool gaussWindow); float minSpeedOfSound, float maxSpeedOfSound, bool gaussWindow);
@@ -79,7 +77,7 @@ DetectResult
transmissionDetection( transmissionDetection(
const Aurora::CudaMatrix &AscanBlock, const Aurora::CudaMatrix &AscanRefBlock, const Aurora::CudaMatrix &AscanBlock, const Aurora::CudaMatrix &AscanRefBlock,
const Aurora::CudaMatrix &distBlock, const Aurora::CudaMatrix &distRefBlock, const Aurora::CudaMatrix &distBlock, const Aurora::CudaMatrix &distRefBlock,
const Aurora::Matrix &sosWaterBlock, const Aurora::Matrix &sosWaterRefBlock, float expectedSOSWater); float aSOSWater, float aSOSWaterRef);
} // namespace Recon } // namespace Recon

35
src/transmissionReconstruction/detection/getTransmissionData.cpp
View File

@@ -1,4 +1,5 @@
#include "getTransmissionData.h" #include "getTransmissionData.h"
#include "common/getMeasurementMetaData.h"
#include "getTransmissionData.cuh" #include "getTransmissionData.cuh"
#include "AuroraDefs.h" #include "AuroraDefs.h"
#include "CudaMatrix.h" #include "CudaMatrix.h"
@@ -45,14 +46,12 @@ namespace
Matrix attData; Matrix attData;
Matrix senderBlock; Matrix senderBlock;
Matrix receiverBlock; Matrix receiverBlock;
Matrix waterTempBlock;
MetaInfos metaInfos; MetaInfos metaInfos;
CudaMatrix ascanBlock; CudaMatrix ascanBlock;
CudaMatrix ascanBlockRef; CudaMatrix ascanBlockRef;
Matrix dists; Matrix dists;
Matrix distRefBlock; Matrix distRefBlock;
Matrix waterTempRefBlock;
}; };
std::map<std::string, BlockOfTransmissionData> BLOCK_OF_TRANSIMISSIONDARA_BUFFER; std::map<std::string, BlockOfTransmissionData> BLOCK_OF_TRANSIMISSIONDARA_BUFFER;
@@ -79,7 +78,7 @@ namespace
} }
BlockOfTransmissionData getBlockOfTransmissionData(const Matrix& aMp, const Matrix& aMpRef, const Matrix& aSl, const Matrix& aSn, const Matrix& aRlList, const Matrix& aRnList, BlockOfTransmissionData getBlockOfTransmissionData(const Matrix& aMp, const Matrix& aMpRef, const Matrix& aSl, const Matrix& aSn, const Matrix& aRlList, const Matrix& aRnList,
const TasTemps& aTasTemps, const Matrix& aExpectedSOSWater, GeometryInfo aGeom, GeometryInfo& aGeomRef, const TempInfo& aTemp, const TempInfo& aTempRef, GeometryInfo aGeom, GeometryInfo& aGeomRef,
const Matrix& aSnrRmsNoise, const Matrix& aSnrRmsNoiseRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef, const Matrix& aSnrRmsNoise, const Matrix& aSnrRmsNoiseRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef,
const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef) const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef)
{ {
@@ -136,9 +135,6 @@ namespace
Matrix dists = distanceBetweenTwoPoints(blockData.senderPositionBlock, blockData.receiverPositionBlock); Matrix dists = distanceBetweenTwoPoints(blockData.senderPositionBlock, blockData.receiverPositionBlock);
Matrix distRefBlock = distanceBetweenTwoPoints(blockDataRef.senderPositionBlock, blockDataRef.receiverPositionBlock); Matrix distRefBlock = distanceBetweenTwoPoints(blockDataRef.senderPositionBlock, blockDataRef.receiverPositionBlock);
Matrix waterTempBlock = calculateWaterTemperature(aTasTemps.waterTempPreCalc_sl, aTasTemps.waterTempPreCalc_rl, blockData.slBlock, blockData.rlBlock, blockData.mpBlock);
Matrix waterTempRefBlock = calculateWaterTemperature(aTasTemps.waterTempRefPreCalc_sl, aTasTemps.waterTempRefPreCalc_rl, blockData.slBlock, blockData.rlBlock, blockDataRef.mpBlock);
if(transParams::saveDetection || transParams::outlierOnTasDetection || transParams::saveDebugInfomation) if(transParams::saveDetection || transParams::outlierOnTasDetection || transParams::saveDebugInfomation)
{ {
metaInfos.mpBlock = blockData.mpBlock; metaInfos.mpBlock = blockData.mpBlock;
@@ -150,13 +146,11 @@ namespace
result.metaInfos = metaInfos; result.metaInfos = metaInfos;
result.senderBlock = blockData.senderPositionBlock; result.senderBlock = blockData.senderPositionBlock;
result.receiverBlock = blockData.receiverPositionBlock; result.receiverBlock = blockData.receiverPositionBlock;
result.waterTempBlock = waterTempBlock;
result.ascanBlock = ascanBlock; result.ascanBlock = ascanBlock;
result.ascanBlockRef = ascanBlockRef; result.ascanBlockRef = ascanBlockRef;
result.dists = dists; result.dists = dists;
result.distRefBlock = distRefBlock; result.distRefBlock = distRefBlock;
result.waterTempRefBlock = waterTempRefBlock;
// DetectResult detect = transmissionDetection(ascanBlock, ascanBlockRef, dists, distRefBlock, waterTempBlock, waterTempRefBlock, aExpectedSOSWater[0]); // DetectResult detect = transmissionDetection(ascanBlock, ascanBlockRef, dists, distRefBlock, waterTempBlock, waterTempRefBlock, aExpectedSOSWater[0]);
// result.attData = detect.att; // result.attData = detect.att;
@@ -168,13 +162,13 @@ namespace
} }
void getBlockOfTransmissionDataInThread(size_t aIndex, const Matrix& aMp, const Matrix& aMpRef, const Matrix& aSl, const Matrix& aSn, const Matrix& aRlList, const Matrix& aRnList, void getBlockOfTransmissionDataInThread(size_t aIndex, const Matrix& aMp, const Matrix& aMpRef, const Matrix& aSl, const Matrix& aSn, const Matrix& aRlList, const Matrix& aRnList,
const TasTemps& aTasTemps, const Matrix& aExpectedSOSWater, GeometryInfo aGeom, GeometryInfo aGeomRef, const TempInfo& aTemp, const TempInfo& aTempRef, GeometryInfo aGeom, GeometryInfo aGeomRef,
const Matrix& aSnrRmsNoise, const Matrix& aSnrRmsNoiseRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef, const Matrix& aSnrRmsNoise, const Matrix& aSnrRmsNoiseRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef,
const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef, unsigned int aGPUId) const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef, unsigned int aGPUId)
{ {
cudaSetDevice(aGPUId); cudaSetDevice(aGPUId);
auto buffer = getBlockOfTransmissionData(aMp, aMpRef, aSl, aSn, aRlList, aRnList, aTasTemps, auto buffer = getBlockOfTransmissionData(aMp, aMpRef, aSl, aSn, aRlList, aRnList, aTemp,
aExpectedSOSWater, aGeom, aGeomRef, aSnrRmsNoise, aSnrRmsNoiseRef, aTempRef, aGeom, aGeomRef, aSnrRmsNoise, aSnrRmsNoiseRef,
aExpInfo, aExpInfoRef, aPreComputes, aParser, aParserRef); aExpInfo, aExpInfoRef, aPreComputes, aParser, aParserRef);
std::unique_lock<std::mutex> lock(CREATE_BUFFER_MUTEX); std::unique_lock<std::mutex> lock(CREATE_BUFFER_MUTEX);
BLOCK_OF_TRANSIMISSIONDARA_BUFFER[std::to_string(aIndex)] = buffer; BLOCK_OF_TRANSIMISSIONDARA_BUFFER[std::to_string(aIndex)] = buffer;
@@ -184,7 +178,7 @@ void getBlockOfTransmissionDataInThread(size_t aIndex, const Matrix& aMp, const
} }
void createThreadForGetBlockOfTransmissionData(const Matrix& aMotorPos, const Matrix& aMotoPosRef, const Matrix& aSlList, const Matrix& aSnList, const Matrix& aRlList, const Matrix& aRnList, void createThreadForGetBlockOfTransmissionData(const Matrix& aMotorPos, const Matrix& aMotoPosRef, const Matrix& aSlList, const Matrix& aSnList, const Matrix& aRlList, const Matrix& aRnList,
const TasTemps& aTasTemps, const Matrix& aExpectedSOSWater, GeometryInfo aGeom, GeometryInfo aGeomRef, const TempInfo& aTemp, const TempInfo& aTempRef, GeometryInfo aGeom, GeometryInfo aGeomRef,
const Matrix& aSnrRmsNoise, const Matrix& aSnrRmsNoiseRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef, const Matrix& aSnrRmsNoise, const Matrix& aSnrRmsNoiseRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef,
const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef) const PreComputes& aPreComputes, Parser* aParser, Parser* aParserRef)
{ {
@@ -208,7 +202,7 @@ void createThreadForGetBlockOfTransmissionData(const Matrix& aMotorPos, const M
CREATE_BUFFER_CONDITION.wait(lock, []{return BUFFER_COUNT<BUFFER_SIZE;}); CREATE_BUFFER_CONDITION.wait(lock, []{return BUFFER_COUNT<BUFFER_SIZE;});
++BUFFER_COUNT; ++BUFFER_COUNT;
lock.unlock(); lock.unlock();
speedUpThread[index] = std::thread(getBlockOfTransmissionDataInThread,index,mp,mpRef,sl,sn,aRlList,aRnList,aTasTemps,aExpectedSOSWater,aGeom,aGeomRef,aSnrRmsNoise,aSnrRmsNoiseRef,aExpInfo,aExpInfoRef,aPreComputes,aParser, aParserRef, index % BUFFER_SIZE); speedUpThread[index] = std::thread(getBlockOfTransmissionDataInThread,index,mp,mpRef,sl,sn,aRlList,aRnList,aTemp,aTempRef,aGeom,aGeomRef,aSnrRmsNoise,aSnrRmsNoiseRef,aExpInfo,aExpInfoRef,aPreComputes,aParser, aParserRef, index % BUFFER_SIZE);
} }
} }
} }
@@ -232,11 +226,6 @@ TransmissionData Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, con
// % Load transmission detection data // % Load transmission detection data
// writeReconstructionLog('Loading transmission detection data. All available data from given motor positions are taken.', 1); // writeReconstructionLog('Loading transmission detection data. All available data from given motor positions are taken.', 1);
// [tofDataTotal, attDataTotal, senderList, receiverList, waterTempList, dataInfo] = loadTransmissionDetectionData(transParams.pathSaveDetection, transParams.pathData, motorPos, expInfo.rootMeasUniqueID); // [tofDataTotal, attDataTotal, senderList, receiverList, waterTempList, dataInfo] = loadTransmissionDetectionData(transParams.pathSaveDetection, transParams.pathData, motorPos, expInfo.rootMeasUniqueID);
TasTemps tasTemps;
tasTemps.waterTempPreCalc_rl = extractTasTemperature(aTemp.tasTemperature, aRlList, aMotorPos, aTemp.jumoTemp, transParams::minTemperature, transParams::maxTemperature);
tasTemps.waterTempPreCalc_sl = extractTasTemperature(aTemp.tasTemperature, aSlList, aMotorPos, aTemp.jumoTemp, transParams::minTemperature, transParams::maxTemperature);
tasTemps.waterTempRefPreCalc_rl = extractTasTemperature(aTempRef.tasTemperature, aRlList, aMotoPosRef, aTempRef.jumoTemp, transParams::minTemperature, transParams::maxTemperature);
tasTemps.waterTempRefPreCalc_sl = extractTasTemperature(aTempRef.tasTemperature, aSlList, aMotoPosRef, aTempRef.jumoTemp, transParams::minTemperature, transParams::maxTemperature);
aGeom.sensData = precalcSensitivity(aSlList, aSnList, aRlList, aRnList, aMotorPos, aGeom); aGeom.sensData = precalcSensitivity(aSlList, aSnList, aRlList, aRnList, aMotorPos, aGeom);
aGeomRef.sensData = aGeom.sensData; aGeomRef.sensData = aGeom.sensData;
@@ -251,7 +240,6 @@ TransmissionData Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, con
size_t numScans = aMotorPos.getDataSize() * aSlList.getDataSize() * aSnList.getDataSize() * aRlList.getDataSize() * aRnList.getDataSize(); size_t numScans = aMotorPos.getDataSize() * aSlList.getDataSize() * aSnList.getDataSize() * aRlList.getDataSize() * aRnList.getDataSize();
Matrix tofDataTotal = Matrix::fromRawData(new float[numScans], 1, numScans) + NAN; Matrix tofDataTotal = Matrix::fromRawData(new float[numScans], 1, numScans) + NAN;
Matrix attDataTotal = Matrix::fromRawData(new float[numScans], 1, numScans) + NAN; Matrix attDataTotal = Matrix::fromRawData(new float[numScans], 1, numScans) + NAN;
Matrix waterTempList = zeros(1,numScans,1);
Matrix senderList = zeros(3,numScans,1); Matrix senderList = zeros(3,numScans,1);
Matrix receiverList = zeros(3,numScans,1); Matrix receiverList = zeros(3,numScans,1);
Matrix snrValues = zeros(1,numScans,1); Matrix snrValues = zeros(1,numScans,1);
@@ -271,7 +259,7 @@ TransmissionData Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, con
rnBlockTotal = zeros(1,numScans,1); rnBlockTotal = zeros(1,numScans,1);
} }
std::thread speedUpThread = std::thread(createThreadForGetBlockOfTransmissionData,aMotorPos,aMotoPosRef,aSlList,aSnList,aRlList,aRnList,tasTemps,aTemp.expectedSOSWater,aGeom,aGeomRef,rmsNoise,rmsNoiseRef,aExpInfo,aExpInfoRef,aPreComputes,aParser, aParserRef); std::thread speedUpThread = std::thread(createThreadForGetBlockOfTransmissionData,aMotorPos,aMotoPosRef,aSlList,aSnList,aRlList,aRnList,aTemp,aTempRef,aGeom,aGeomRef,rmsNoise,rmsNoiseRef,aExpInfo,aExpInfoRef,aPreComputes,aParser, aParserRef);
int numData = 0; int numData = 0;
int numPossibleScans = 0; int numPossibleScans = 0;
sched_param sch; sched_param sch;
@@ -300,8 +288,7 @@ TransmissionData Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, con
cudaSetDevice(index % BUFFER_SIZE); cudaSetDevice(index % BUFFER_SIZE);
DetectResult detect = transmissionDetection( blockData.ascanBlock, blockData.ascanBlockRef, DetectResult detect = transmissionDetection( blockData.ascanBlock, blockData.ascanBlockRef,
blockData.dists.toDeviceMatrix(), blockData.distRefBlock.toDeviceMatrix(), blockData.dists.toDeviceMatrix(), blockData.distRefBlock.toDeviceMatrix(),
blockData.waterTempBlock, blockData.waterTempRefBlock, aTemp.expectedSOSWater[0], aTempRef.expectedSOSWater[0]);
aTemp.expectedSOSWater[0]);
blockData.attData = detect.att; blockData.attData = detect.att;
blockData.tofData = detect.tof; blockData.tofData = detect.tof;
BlockOfTransmissionData transmissionBlock=blockData; BlockOfTransmissionData transmissionBlock=blockData;
@@ -317,7 +304,6 @@ TransmissionData Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, con
cblas_scopy(numUsedData * rows, transmissionBlock.receiverBlock.getData(), 1, receiverList.getData() + numData*rows, 1); cblas_scopy(numUsedData * rows, transmissionBlock.receiverBlock.getData(), 1, receiverList.getData() + numData*rows, 1);
cblas_scopy(numUsedData, transmissionBlock.tofData.getData(), 1, tofDataTotal.getData() + numData, 1); cblas_scopy(numUsedData, transmissionBlock.tofData.getData(), 1, tofDataTotal.getData() + numData, 1);
cblas_scopy(numUsedData, transmissionBlock.attData.getData(), 1, attDataTotal.getData() + numData, 1); cblas_scopy(numUsedData, transmissionBlock.attData.getData(), 1, attDataTotal.getData() + numData, 1);
cblas_scopy(numUsedData, transmissionBlock.waterTempBlock.getData(), 1, waterTempList.getData() + numData, 1);
numData += numUsedData; numData += numUsedData;
std::unique_lock<std::mutex> lockBufferCount(CREATE_BUFFER_MUTEX); std::unique_lock<std::mutex> lockBufferCount(CREATE_BUFFER_MUTEX);
@@ -353,7 +339,6 @@ TransmissionData Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, con
receiverList = removeDataFromArrays(receiverList, filter); receiverList = removeDataFromArrays(receiverList, filter);
tofDataTotal = removeDataFromArrays(tofDataTotal, filter); tofDataTotal = removeDataFromArrays(tofDataTotal, filter);
attDataTotal = removeDataFromArrays(attDataTotal, filter); attDataTotal = removeDataFromArrays(attDataTotal, filter);
waterTempList = removeDataFromArrays(waterTempList, filter);
Matrix valid; Matrix valid;
if(transParams::applyCalib) if(transParams::applyCalib)
@@ -383,7 +368,6 @@ TransmissionData Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, con
attDataTotal = removeDataFromArrays(attDataTotal, valid); attDataTotal = removeDataFromArrays(attDataTotal, valid);
senderList = removeDataFromArrays(senderList, valid); senderList = removeDataFromArrays(senderList, valid);
receiverList = removeDataFromArrays(receiverList, valid); receiverList = removeDataFromArrays(receiverList, valid);
waterTempList = removeDataFromArrays(waterTempList, valid);
dataInfno.numPossibleScans = numData; dataInfno.numPossibleScans = numData;
dataInfno.numValidScans = sum(valid); dataInfno.numValidScans = sum(valid);
@@ -439,6 +423,5 @@ TransmissionData Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, con
result.receiverList = receiverList; result.receiverList = receiverList;
result.senderList = senderList; result.senderList = senderList;
result.dataInfo = dataInfno; result.dataInfo = dataInfno;
result.waterTempList = waterTempList;
return result; return result;
} }

1
src/transmissionReconstruction/detection/getTransmissionData.h
View File

@@ -37,7 +37,6 @@ namespace Recon
Aurora::Matrix attDataTotal; Aurora::Matrix attDataTotal;
Aurora::Matrix senderList; Aurora::Matrix senderList;
Aurora::Matrix receiverList; Aurora::Matrix receiverList;
Aurora::Matrix waterTempList;
DataInfo dataInfo; DataInfo dataInfo;
}; };

4
src/transmissionReconstruction/startTransmissionReconstruction.cpp
View File

@@ -3,6 +3,7 @@
#include "Function2D.h" #include "Function2D.h"
#include "MatlabWriter.h" #include "MatlabWriter.h"
#include "Matrix.h"
#include "detection/getTransmissionData.h" #include "detection/getTransmissionData.h"
#include "log/log.h" #include "log/log.h"
#include "config/config.h" #include "config/config.h"
@@ -26,9 +27,8 @@ TransmissionReconstructionResult Recon::startTransmissionReconstruction(const Au
auto transmissionData = getTransmissionData(aMotorPos, aMotoPosRef, aSlList, aSnList, aRlList, aRnList, aTemp, aTempRef, auto transmissionData = getTransmissionData(aMotorPos, aMotoPosRef, aSlList, aSnList, aRlList, aRnList, aTemp, aTempRef,
aGeom, aGeomRef, aExpInfo, aExpInfoRef, aPreComputes, aParser, aParserRef); aGeom, aGeomRef, aExpInfo, aExpInfoRef, aPreComputes, aParser, aParserRef);
Matrix dists = Recon::distanceBetweenTwoPoints(transmissionData.senderList, transmissionData.receiverList); Matrix dists = Recon::distanceBetweenTwoPoints(transmissionData.senderList, transmissionData.receiverList);
Matrix sosRef = Recon::temperatureToSoundSpeed(transmissionData.waterTempList, "marczak");
Matrix valid = Recon::checkTofDetections(transmissionData.tofDataTotal, dists, sosRef, Matrix valid = Recon::checkTofDetections(transmissionData.tofDataTotal, dists, aTemp.expectedSOSWater[0],
Recon::transParams::minSpeedOfSound,Recon::transParams::maxSpeedOfSound).valid; Recon::transParams::minSpeedOfSound,Recon::transParams::maxSpeedOfSound).valid;
if(transParams::qualityCheck) if(transParams::qualityCheck)
{ {

40
test/DataFilter_Test.cpp
View File

@@ -74,28 +74,28 @@ TEST_F(DataFilter_Test, filterTransmissionAngle) {
} }
TEST_F(DataFilter_Test, checkTofDetections) { // TEST_F(DataFilter_Test, checkTofDetections) {
MatlabReader m("/home/sun/testData/checkTofDetections.mat"); // MatlabReader m("/home/sun/testData/checkTofDetections.mat");
auto receiverList = m.read("receiverList"); // auto receiverList = m.read("receiverList");
auto senderList = m.read("senderList"); // auto senderList = m.read("senderList");
auto tofDataTotal = m.read("tofDataTotal"); // auto tofDataTotal = m.read("tofDataTotal");
auto waterTempList = m.read("waterTempList"); // auto waterTempList = m.read("waterTempList");
auto tofValues = m.read("tofValues"); // auto tofValues = m.read("tofValues");
auto valid = m.read("valid"); // auto valid = m.read("valid");
Aurora::Matrix dists = Recon::distanceBetweenTwoPoints(senderList, receiverList); // Aurora::Matrix dists = Recon::distanceBetweenTwoPoints(senderList, receiverList);
Aurora::Matrix sosRef = Recon::temperatureToSoundSpeed(waterTempList, "marczak"); // Aurora::Matrix sosRef = Recon::temperatureToSoundSpeed(waterTempList, "marczak");
auto result = Recon::checkTofDetections(tofDataTotal, dists, sosRef, Recon::transParams::minSpeedOfSound,Recon::transParams::maxSpeedOfSound); // auto result = Recon::checkTofDetections(tofDataTotal, dists, sosRef, Recon::transParams::minSpeedOfSound,Recon::transParams::maxSpeedOfSound);
for (size_t i = 0; i < result.valid.getDataSize(); i++) // for (size_t i = 0; i < result.valid.getDataSize(); i++)
{ // {
EXPECT_FLOAT_AE(valid.getData()[i],result.valid.getData()[i]) << " :"<<i; // EXPECT_FLOAT_AE(valid.getData()[i],result.valid.getData()[i]) << " :"<<i;
} // }
for (size_t i = 0; i < result.tofValues.getDataSize(); i++) // for (size_t i = 0; i < result.tofValues.getDataSize(); i++)
{ // {
EXPECT_FLOAT_AE(tofValues.getData()[i],result.tofValues.getData()[i])<< " :"<<i; // EXPECT_FLOAT_AE(tofValues.getData()[i],result.tofValues.getData()[i])<< " :"<<i;
} // }
} // }
TEST_F(DataFilter_Test, calculateSnr) { TEST_F(DataFilter_Test, calculateSnr) {
MatlabReader m("/home/krad/TestData/snr.mat"); MatlabReader m("/home/krad/TestData/snr.mat");

214
test/Detection_Test.cpp
View File

@@ -38,83 +38,83 @@ protected:
} }
}; };
TEST_F(Detection_Test, detectTofAndAtt) { // TEST_F(Detection_Test, detectTofAndAtt) {
MatlabReader m("/home/sun/testData/transmissionDetection.mat"); // MatlabReader m("/home/sun/testData/transmissionDetection.mat");
auto AscanBlock = m.read("AscanBlock"); // auto AscanBlock = m.read("AscanBlock");
auto AscanRefBlock = m.read("AscanRefBlock"); // auto AscanRefBlock = m.read("AscanRefBlock");
auto distBlock = m.read("dists"); // auto distBlock = m.read("dists");
auto distBlockRef = m.read("distRefBlock"); // auto distBlockRef = m.read("distRefBlock");
auto sosWaterBlock = Recon::temperatureToSoundSpeed(m.read("waterTempBlock"), "marczak"); // auto sosWaterBlock = Recon::temperatureToSoundSpeed(m.read("waterTempBlock"), "marczak");
auto sosWaterRefBlock = Recon::temperatureToSoundSpeed(m.read("waterTempRefBlock"), "marczak"); // auto sosWaterRefBlock = Recon::temperatureToSoundSpeed(m.read("waterTempRefBlock"), "marczak");
float expectedSOSWater = 1.512677498767504e+03; // float expectedSOSWater = 1.512677498767504e+03;
auto result = Recon::detectTofAndAtt( // auto result = Recon::detectTofAndAtt(
AscanBlock, AscanRefBlock, distBlock, distBlockRef, sosWaterBlock, // AscanBlock, AscanRefBlock, distBlock, distBlockRef, sosWaterBlock,
sosWaterRefBlock, Recon::transParams::resampleFactor, // sosWaterRefBlock, Recon::transParams::resampleFactor,
Recon::transParams::nThreads, expectedSOSWater, // Recon::transParams::nThreads, expectedSOSWater,
Recon::transParams::useTimeWindowing, // Recon::transParams::useTimeWindowing,
Recon::transParams::aScanReconstructionFrequency, // Recon::transParams::aScanReconstructionFrequency,
Recon::transParams::detectionWindowATT,Recon::transParams::offsetElectronic, // Recon::transParams::detectionWindowATT,Recon::transParams::offsetElectronic,
Recon::transParams::detectionWindowSOS, // Recon::transParams::detectionWindowSOS,
Recon::transParams::minSpeedOfSound, // Recon::transParams::minSpeedOfSound,
Recon::transParams::maxSpeedOfSound, Recon::transParams::gaussWindow); // Recon::transParams::maxSpeedOfSound, Recon::transParams::gaussWindow);
MatlabReader m2("/home/krad/TestData/sosResult.mat"); // MatlabReader m2("/home/krad/TestData/sosResult.mat");
auto sosvalue = m2.read("sosValue"); // auto sosvalue = m2.read("sosValue");
auto tof = m2.read("tofRel"); // auto tof = m2.read("tofRel");
auto att = m2.read("att"); // auto att = m2.read("att");
// auto result1 = Recon::detectTofAndAttMex( // // auto result1 = Recon::detectTofAndAttMex(
// AscanBlock, AscanRefBlock, distBlock, distBlockRef, sosWaterBlock, // // AscanBlock, AscanRefBlock, distBlock, distBlockRef, sosWaterBlock,
// sosWaterRefBlock, Recon::transParams::resampleFactor, // // sosWaterRefBlock, Recon::transParams::resampleFactor,
// Recon::transParams::nThreads, expectedSOSWater, // // Recon::transParams::nThreads, expectedSOSWater,
// Recon::transParams::useTimeWindowing, // // Recon::transParams::useTimeWindowing,
// Recon::transParams::aScanReconstructionFrequency, // // Recon::transParams::aScanReconstructionFrequency,
// Recon::transParams::detectionWindowATT,Recon::transParams::offsetElectronic, // // Recon::transParams::detectionWindowATT,Recon::transParams::offsetElectronic,
// Recon::transParams::detectionWindowSOS, // // Recon::transParams::detectionWindowSOS,
// Recon::transParams::minSpeedOfSound, // // Recon::transParams::minSpeedOfSound,
// Recon::transParams::maxSpeedOfSound, Recon::transParams::gaussWindow); // // Recon::transParams::maxSpeedOfSound, Recon::transParams::gaussWindow);
ASSERT_EQ(sosvalue.getDataSize(), result.tof.getDataSize()); // ASSERT_EQ(sosvalue.getDataSize(), result.tof.getDataSize());
ASSERT_EQ(sosvalue.getDataSize(), result.sosValue.getDataSize()); // ASSERT_EQ(sosvalue.getDataSize(), result.sosValue.getDataSize());
ASSERT_EQ(sosvalue.getDataSize(), result.att.getDataSize()); // ASSERT_EQ(sosvalue.getDataSize(), result.att.getDataSize());
#pragma omp parallel for // #pragma omp parallel for
for (size_t i = 0; i < result.tof.getDataSize(); i++) // for (size_t i = 0; i < result.tof.getDataSize(); i++)
{ // {
EXPECT_DOUBLE_AE(tof[i],result.tof[i])<<",index:"<<i; // EXPECT_DOUBLE_AE(tof[i],result.tof[i])<<",index:"<<i;
EXPECT_DOUBLE_AE(sosvalue[i],result.sosValue[i])<<",index:"<<i; // EXPECT_DOUBLE_AE(sosvalue[i],result.sosValue[i])<<",index:"<<i;
// EXPECT_DOUBLE_AE(result1.att[i],result.att[i])<<",index:"<<i; // // EXPECT_DOUBLE_AE(result1.att[i],result.att[i])<<",index:"<<i;
// EXPECT_TRUE((std::abs(att[i]-result.att[i])<0.001))<<",att["<<i<<"]"<<att[i]<<", res att["<<i<<"]"<<result.att[1]; // // EXPECT_TRUE((std::abs(att[i]-result.att[i])<0.001))<<",att["<<i<<"]"<<att[i]<<", res att["<<i<<"]"<<result.att[1];
} // }
} // }
TEST_F(Detection_Test, detectAttVectorized) { // TEST_F(Detection_Test, detectAttVectorized) {
MatlabReader m("/home/krad/TestData/getBlockOfTransmissionData.mat"); // MatlabReader m("/home/krad/TestData/getBlockOfTransmissionData.mat");
auto AscanBlock = m.read("AscanBlock"); // auto AscanBlock = m.read("AscanBlock");
auto AscanRefBlock = m.read("AscanRefBlock"); // auto AscanRefBlock = m.read("AscanRefBlock");
auto distBlockRef = m.read("distRefBlock"); // auto distBlockRef = m.read("distRefBlock");
auto sosWaterRefBlock = m.read("waterTempRefBlock"); // auto sosWaterRefBlock = m.read("waterTempRefBlock");
MatlabReader m2("/home/krad/TestData/tofResult.mat"); // MatlabReader m2("/home/krad/TestData/tofResult.mat");
auto tof = m2.read("tof"); // auto tof = m2.read("tof");
float expectedSOSWater = 1.511948131508464e+03; // float expectedSOSWater = 1.511948131508464e+03;
auto result = Recon::detectAttVectorized( // auto result = Recon::detectAttVectorized(
AscanBlock, AscanRefBlock, distBlockRef,sosWaterRefBlock, // AscanBlock, AscanRefBlock, distBlockRef,sosWaterRefBlock,
tof, // tof,
Recon::transParams::aScanReconstructionFrequency, // Recon::transParams::aScanReconstructionFrequency,
Recon::transParams::offsetElectronic, // Recon::transParams::offsetElectronic,
Recon::transParams::detectionWindowSOS); // Recon::transParams::detectionWindowSOS);
for (size_t i = 0; i < result.getDataSize(); i++) // for (size_t i = 0; i < result.getDataSize(); i++)
{ // {
EXPECT_TRUE(std::isnan(result[i]))<<",index:"<<i; // EXPECT_TRUE(std::isnan(result[i]))<<",index:"<<i;
} // }
} // }
TEST_F(Detection_Test, calculateStarEndSearchPosition) { TEST_F(Detection_Test, calculateStarEndSearchPosition) {
@@ -151,54 +151,54 @@ TEST_F(Detection_Test, calculateAttenuation) {
} }
} }
TEST_F(Detection_Test, applyTimeWindowing) { // TEST_F(Detection_Test, applyTimeWindowing) {
MatlabReader m("/home/krad/TestData/timeWindow2.mat"); // MatlabReader m("/home/krad/TestData/timeWindow2.mat");
auto AscanBlock = m.read("AscanBlock"); // auto AscanBlock = m.read("AscanBlock");
auto distBlock = m.read("dists"); // auto distBlock = m.read("dists");
auto sosBlock = m.read("waterTempBlock"); // auto sosBlock = m.read("waterTempBlock");
auto AscanBlockProcessed = m.read("AscanBlock1"); // auto AscanBlockProcessed = m.read("AscanBlock1");
auto startSearch = m.read("startSearch"); // auto startSearch = m.read("startSearch");
auto result = Recon::applyTimeWindowing(AscanBlock, 10000000, distBlock, sosBlock, 1.511948131508464e+03, 5.2, 1, 1450, 1550, false); // auto result = Recon::applyTimeWindowing(AscanBlock, 10000000, distBlock, sosBlock, 1.511948131508464e+03, 5.2, 1, 1450, 1550, false);
#pragma omp parallel for // #pragma omp parallel for
for (size_t i = 0; i < AscanBlockProcessed.getDataSize(); i++) // for (size_t i = 0; i < AscanBlockProcessed.getDataSize(); i++)
{ // {
EXPECT_DOUBLE_AE(AscanBlockProcessed[i],result.AscanBlockProcessed[i])<<",index:"<<i; // EXPECT_DOUBLE_AE(AscanBlockProcessed[i],result.AscanBlockProcessed[i])<<",index:"<<i;
} // }
} // }
TEST_F(Detection_Test, detectTofVectorized) { // TEST_F(Detection_Test, detectTofVectorized) {
MatlabReader m("/home/krad/TestData/getBlockOfTransmissionData.mat"); // MatlabReader m("/home/krad/TestData/getBlockOfTransmissionData.mat");
auto AscanBlock = m.read("AscanBlock"); // auto AscanBlock = m.read("AscanBlock");
auto AscanRefBlock = m.read("AscanRefBlock"); // auto AscanRefBlock = m.read("AscanRefBlock");
auto distBlock = m.read("dists"); // auto distBlock = m.read("dists");
auto distBlockRef = m.read("distRefBlock"); // auto distBlockRef = m.read("distRefBlock");
auto sosWaterBlock = m.read("waterTempBlock"); // auto sosWaterBlock = m.read("waterTempBlock");
auto sosWaterRefBlock = m.read("waterTempRefBlock"); // auto sosWaterRefBlock = m.read("waterTempRefBlock");
float expectedSOSWater = 1.511948131508464e+03; // float expectedSOSWater = 1.511948131508464e+03;
auto result = Recon::detectTofVectorized( // auto result = Recon::detectTofVectorized(
AscanBlock, AscanRefBlock, distBlock, distBlockRef, sosWaterBlock, // AscanBlock, AscanRefBlock, distBlock, distBlockRef, sosWaterBlock,
sosWaterRefBlock, expectedSOSWater, // sosWaterRefBlock, expectedSOSWater,
Recon::transParams::useTimeWindowing, // Recon::transParams::useTimeWindowing,
Recon::transParams::aScanReconstructionFrequency, // Recon::transParams::aScanReconstructionFrequency,
Recon::transParams::offsetElectronic, // Recon::transParams::offsetElectronic,
Recon::transParams::detectionWindowSOS, // Recon::transParams::detectionWindowSOS,
Recon::transParams::minSpeedOfSound, // Recon::transParams::minSpeedOfSound,
Recon::transParams::maxSpeedOfSound, Recon::transParams::gaussWindow); // Recon::transParams::maxSpeedOfSound, Recon::transParams::gaussWindow);
MatlabReader m2("/home/krad/TestData/tofResult.mat"); // MatlabReader m2("/home/krad/TestData/tofResult.mat");
auto tof = m2.read("tof"); // auto tof = m2.read("tof");
auto sosvalue = m2.read("sosValue"); // auto sosvalue = m2.read("sosValue");
EXPECT_EQ(tof.getDataSize(), result.tof.getDataSize()); // EXPECT_EQ(tof.getDataSize(), result.tof.getDataSize());
#pragma omp parallel for // #pragma omp parallel for
for (size_t i = 0; i < tof.getDataSize(); i++) // for (size_t i = 0; i < tof.getDataSize(); i++)
{ // {
EXPECT_DOUBLE_AE(tof[i],result.tof[i])<<",index:"<<i; // EXPECT_DOUBLE_AE(tof[i],result.tof[i])<<",index:"<<i;
} // }
} // }