diff --git a/CMakeLists.txt b/CMakeLists.txt
index 70ee0dc..428c499 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -60,7 +60,8 @@ INCLUDE_DIRECTORIES(${GTEST_INCLUDE_DIRS})
 
 enable_testing()
 file(GLOB_RECURSE  test_cpp test/*.cpp)
-add_executable(UR_Test ${cpp_files} ${header_files} ${Aurora_Source} ${test_cpp} )
+add_executable(UR_Test ${cpp_files} ${header_files} ${Aurora_Source} ${test_cpp} ${cu_files} ${Aurora_Source} ${Aurora_Source_Cu} ./src/Aurora.cu ${Aurora_DIR}/src/CudaMatrixPrivate.cu)
+
 target_include_directories(UR_Test PUBLIC ./test/ ./src/)
 # target_compile_options(UR_Test PUBLIC ${Aurora_Complie_Options} "-march=native")
 target_include_directories(UR_Test PUBLIC ${DCMTK_INCLUDE_DIRS})
@@ -79,5 +80,12 @@ target_link_libraries(UR_Test PUBLIC URDepends::eikonal)
 target_link_libraries(UR_Test PUBLIC URDepends::TVALGPU)
 target_link_libraries(UR_Test PUBLIC URDepends::SaftTofi)
 # target_link_libraries(UR_Test PUBLIC URDepends::SaftATT)
+target_include_directories(UR_Test PRIVATE ./src /usr/local/cuda/include) 
+set_target_properties(UR_Test PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
+target_compile_options(UR_Test PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:
+    -arch=sm_75 --expt-extended-lambda 
+>)
+
+target_link_libraries(UR_Test PRIVATE ${CUDA_RUNTIME_LIBRARY} CUDA::cufft CUDA::cudart)
 gtest_discover_tests(UR_Test)
\ No newline at end of file
diff --git a/src/reflectionReconstruction/startReflectionReconstruction.cpp.orig b/src/reflectionReconstruction/startReflectionReconstruction.cpp.orig
deleted file mode 100644
index 15b20ec..0000000
--- a/src/reflectionReconstruction/startReflectionReconstruction.cpp.orig
+++ /dev/null
@@ -1,137 +0,0 @@
-#include "startReflectionReconstruction.h"
-#include "Function.h"
-#include "Function2D.h"
-#include "Function3D.h"
-#include "Matrix.h"
-#include "MatlabWriter.h"
-
-#include "common/getGeometryInfo.h"
-#include "common/precalculateChannelList.h"
-#include "common/dataBlockCreation/getAScanBlockPreprocessed.h"
-#include "common/dataBlockCreation/removeDataFromArrays.h"
-#include "log/notify.h"
-#include "reflectionReconstruction/preprocessData/determineOptimalPulse.h"
-#include "reflectionReconstruction/reconstructionSAFT/reconstructionSAFT.h"
-#include "src/reflectionReconstruction/preprocessData/preprocessAScanBlockForReflection.h"
-#include "config/config.h"
-#include "log/log.h"
-
-#include "CudaEnvInit.h"
-
-#include <cstdio>
-#include <iostream>
-#include <queue>
-#include <thread>
-#include <vector>
-
-using namespace Aurora;
-using namespace Recon;
-
-namespace
-{
-    std::queue<preprocessAScanRResult> PRODUCER_PROCESSDATAS;
-    std::queue<AscanBlockPreprocessed> PRODUCER_BLOCKDATAS;
-    std::mutex PRODUCER_MUTEX;
-    std::condition_variable PRODUCER_CONDITION;
-    std::mutex CUSTOMER_MUTEX;
-    std::condition_variable CUSTOMER_CONDITION;
-}
-
-void producerThread( Parser* aParser, const Aurora::Matrix& aMotorPos,
-                     const Aurora::Matrix& aSlList, const Aurora::Matrix& aSnList,
-                     const Aurora::Matrix& aRlList, const Aurora::Matrix& aRnList,
-                     GeometryInfo& aGeom, MeasurementInfo& aExpInfo, PreComputes& aPreComputes)
-{
-    if(reflectParams::useOptPulse==1 && reflectParams::runReflectionReco)
-    {
-        aPreComputes.sincPeak_ft = determineOptimalPulse(aPreComputes.timeInterval, aExpInfo.expectedAScanLength);
-    }
-    printf("   - channel list");
-    auto channelList = precalculateChannelList(aRlList, aRnList, aExpInfo, aPreComputes);
-    size_t numScans = aMotorPos.getDataSize() * aSlList.getDataSize() *
-                      aSnList.getDataSize() * aRlList.getDataSize() *
-                      aRnList.getDataSize();
-    int numTakenScans = 0,numProcessedScans = 0,numPossibleScans = 0;
-    for(int i=0; i<aMotorPos.getDataSize(); ++i)
-    {
-        //#pragma omp parallel for num_threads(24)
-        for(int j=0; j<aSlList.getDataSize() / transParams::senderTASSize; ++j)
-        {
-            for(int k=0; k<aSnList.getDataSize() / transParams::senderElementSize; ++k)
-            {
-                Matrix mp = aMotorPos(i).toMatrix();
-                Matrix sl = aSlList.block(0, transParams::senderTASSize*j, transParams::senderTASSize*j+transParams::senderTASSize - 1);
-                Matrix sn = aSnList.block(0, transParams::senderElementSize*k, transParams::senderElementSize*k+transParams::senderElementSize - 1);
-                auto blockData = getAscanBlockPreprocessed(aParser, mp, sl, sn, aRlList, aRnList, aGeom, aExpInfo, true, false);
-
-                float* channelListSizeData = Aurora::malloc(2);
-                channelListSizeData[0] = channelList.getDimSize(0);
-                channelListSizeData[1] = channelList.getDimSize(1);
-                Matrix channelListSize = Matrix::New(channelListSizeData, 2, 1);
-                Matrix ind = sub2ind(channelListSize, {blockData.rlBlock, blockData.rnBlock});
-                size_t channelBlockSize = ind.getDataSize();
-                float* channelBlockData = Aurora::malloc(channelBlockSize);
-                for(size_t i=0; i<channelBlockSize; ++i)
-                {
-                    channelBlockData[i] = channelList[ind[i] - 1];
-                }
-                Matrix channelBlock = Matrix::New(channelBlockData, 1, channelBlockSize);
-                RECON_INFO("start cpu---------preprocessAScanBlockForReflection");
-                auto preprocessData = preprocessAScanBlockForReflection(blockData.ascanBlockPreprocessed, blockData.mpBlock, blockData.slBlock,
-                                      blockData.snBlock, blockData.rlBlock, blockData.rnBlock, blockData.senderPositionBlock,
-                                      blockData.receiverPositionBlock, blockData.gainBlock, channelBlock, aExpInfo, aPreComputes);
-                PRODUCER_BLOCKDATAS.push(blockData);
-                PRODUCER_PROCESSDATAS.push(preprocessData);
-            }
-        }
-    }
-}
-
-Aurora::Matrix Recon::startReflectionReconstruction( Parser* aParser, int aSAFT_mode, const Aurora::Matrix& aMotorPos,
-        const Aurora::Matrix& aSlList, const Aurora::Matrix& aSnList,
-        const Aurora::Matrix& aRlList, const Aurora::Matrix& aRnList,
-        GeometryInfo& aGeom, TransRecos& aTransRecos,
-        MeasurementInfo& aExpInfo, PreComputes& aPreComputes)
-{
-    printf("Reflection reconstruction is carried out.");
-
-    printf("Preperations for reconstructions.");
-
-    printf("   - reset GPUs");
-    for (size_t i = 0; i < reflectParams::gpuSelectionList.getDataSize(); i++)
-    {
-        std::string msg;
-        if (!resetGPUDevice((int)reflectParams::gpuSelectionList[i],msg))
-        {
-            std::cerr<<msg<<std::endl;
-        }
-    }
-    std::thread thread = std::thread(producerThread, aParser, aMotorPos, aSlList, aSnList, aRlList, aRnList, aGeom, aExpInfo, aPreComputes);
-
-                                     Matrix Env =  Aurora::zeros((int)reflectParams::imageXYZ[0],(int)reflectParams::imageXYZ[1],(int)reflectParams::imageXYZ[2]);
-
-
-
-
-                                     for(int i=0; i<aMotorPos.getDataSize(); ++i)
-{
-    //#pragma omp parallel for num_threads(24)
-    for(int j=0; j<aSlList.getDataSize() / transParams::senderTASSize; ++j)
-        {
-            for(int k=0; k<aSnList.getDataSize() / transParams::senderElementSize; ++k)
-            {
-                RECON_INFO("start gpu---------recontructSAFT");
-                Env = recontructSAFT(removeDataFromArrays(preprocessData.AscanBlock, preprocessData.usedData),
-                                     removeDataFromArrays(blockData.senderPositionBlock, preprocessData.usedData),
-                                     removeDataFromArrays(blockData.receiverPositionBlock, preprocessData.usedData),
-                                     removeDataFromArrays(blockData.mpBlock, preprocessData.usedData),
-                                     aSAFT_mode, aTransRecos, Env);
-                std::cout<<Env[0]<<"-" << Env[1] <<"-" << Env[2] <<"-" << Env[3]<<std::endl;
-                RECON_INFO("Reflection Reconstructon: " + std::to_string(j));
-            }
-            //Recon::notifyProgress(25+73*((j*i)/(aMotorPos.getDataSize() * aSlList.getDataSize())));
-        }
-    }
-
-    return Env;
-}
\ No newline at end of file
diff --git a/test/Common_Test.cpp b/test/Common_Test.cpp
index b7a712d..0457dd2 100644
--- a/test/Common_Test.cpp
+++ b/test/Common_Test.cpp
@@ -14,12 +14,12 @@
 #include "Parser.h"
 #include "MatlabReader.h"
 
-inline double fourDecimalRound(double src){
+inline float fourDecimalRound(float src){
     return round(src*10000.0)/10000.0;
 }
 
-#define EXPECT_DOUBLE_AE(valueA,valueB)\
-    EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
+#define EXPECT_float_AE(valueA,valueB)\
+    EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
 
 class Common_Test : public ::testing::Test {
 protected:
@@ -47,7 +47,7 @@ TEST_F(Common_Test, adaptFrequency) {
     auto output = m.read("output");
     for (size_t i = 0; i < 4096; i++)
     {
-        EXPECT_DOUBLE_AE(mCe.getData()[i],output.getData()[i])<<", index:"<<i;
+        EXPECT_float_AE(mCe.getData()[i],output.getData()[i])<<", index:"<<i;
     }
     
 }
@@ -57,7 +57,7 @@ TEST_F(Common_Test, convertfp16tofloat) {
 
     size_t count = 0;
     auto input = m.readint16("input",count);
-    auto ma = Aurora::Matrix::copyFromRawData((double*)input.get(),count/4);
+    auto ma = Aurora::Matrix::copyFromRawData((float*)input.get(),count/4);
     auto resultM = Recon::convertfp16tofloat(ma);
     auto result = resultM.getData();
     auto output = m.read("output");
@@ -70,24 +70,24 @@ TEST_F(Common_Test, convertfp16tofloat) {
 TEST_F(Common_Test, convertToLinearIndices) {
     //2D
     {
-        double *dataA = new double[6]{1, 9, 4, 0, .01, 1.9};
+        float *dataA = new float[6]{1, 9, 4, 0, .01, 1.9};
         auto A = Aurora::Matrix::fromRawData(dataA, 3, 2);
-        double *dataB = new double[2]{3, 2};
+        float *dataB = new float[2]{3, 2};
         auto B = Aurora::Matrix::fromRawData(dataB, 2, 1);
         auto output =Recon::convertToLinearIndices(B,A);
-        EXPECT_DOUBLE_AE(-2,output.getData()[0]);
-        EXPECT_DOUBLE_AE(6.03,output.getData()[1]);
-        EXPECT_DOUBLE_AE(6.7,output.getData()[2]);
+        EXPECT_float_AE(-2,output.getData()[0]);
+        EXPECT_float_AE(6.03,output.getData()[1]);
+        EXPECT_float_AE(6.7,output.getData()[2]);
     }
     //3D
     {
-        double *dataA = new double[12]{1, 9, 4, 0, .01, 1.9, 1, 9, 4, 0, .01, 1.9};
+        float *dataA = new float[12]{1, 9, 4, 0, .01, 1.9, 1, 9, 4, 0, .01, 1.9};
         auto A = Aurora::Matrix::fromRawData(dataA, 2, 3, 2);
-        double *dataB = new double[3]{3, 2, 2};
+        float *dataB = new float[3]{3, 2, 2};
         auto B = Aurora::Matrix::fromRawData(dataB, 3, 1);
         auto output =Recon::convertToLinearIndices(B,A);
-        EXPECT_DOUBLE_AE(4.06,output.getData()[0]);
-        EXPECT_DOUBLE_AE(11.4,output.getData()[1]);
+        EXPECT_float_AE(4.06,output.getData()[0]);
+        EXPECT_float_AE(11.4,output.getData()[1]);
     }
 
 
@@ -110,121 +110,121 @@ TEST_F(Common_Test, getGeometryInfo) {
      auto receiverPositions = geom.receiverPositions;
      auto senderNormals = geom.senderNormals;
      auto senderPositions = geom.senderPositions;
-     EXPECT_DOUBLE_EQ(correctReceiverNormals.size(), receiverNormals.size());
+     EXPECT_FLOAT_EQ(correctReceiverNormals.size(), receiverNormals.size());
      for(int i=0;i<correctReceiverNormals.size();++i)
      {
-        EXPECT_DOUBLE_EQ(correctReceiverNormals[i].getDimSize(0), receiverNormals[i].getDimSize(0));
-        EXPECT_DOUBLE_EQ(correctReceiverNormals[i].getDimSize(1), receiverNormals[i].getDimSize(1));
-        EXPECT_DOUBLE_EQ(correctReceiverNormals[i].getDimSize(2), receiverNormals[i].getDimSize(2));
+        EXPECT_FLOAT_EQ(correctReceiverNormals[i].getDimSize(0), receiverNormals[i].getDimSize(0));
+        EXPECT_FLOAT_EQ(correctReceiverNormals[i].getDimSize(1), receiverNormals[i].getDimSize(1));
+        EXPECT_FLOAT_EQ(correctReceiverNormals[i].getDimSize(2), receiverNormals[i].getDimSize(2));
         for(int j=0;j<correctReceiverNormals[i].getDataSize();++j)
         {
-            EXPECT_DOUBLE_AE(correctReceiverNormals[i][j], receiverNormals[i][j]);
+            EXPECT_float_AE(correctReceiverNormals[i][j], receiverNormals[i][j]);
         }
      }
 
-     EXPECT_DOUBLE_EQ(correctReceiverPositions.size(), receiverPositions.size());
+     EXPECT_FLOAT_EQ(correctReceiverPositions.size(), receiverPositions.size());
      for(int i=0;i<correctReceiverPositions.size();++i)
      {
-        EXPECT_DOUBLE_EQ(correctReceiverPositions[i].getDimSize(0), receiverPositions[i].getDimSize(0));
-        EXPECT_DOUBLE_EQ(correctReceiverPositions[i].getDimSize(1), receiverPositions[i].getDimSize(1));
-        EXPECT_DOUBLE_EQ(correctReceiverPositions[i].getDimSize(2), receiverPositions[i].getDimSize(2));
+        EXPECT_FLOAT_EQ(correctReceiverPositions[i].getDimSize(0), receiverPositions[i].getDimSize(0));
+        EXPECT_FLOAT_EQ(correctReceiverPositions[i].getDimSize(1), receiverPositions[i].getDimSize(1));
+        EXPECT_FLOAT_EQ(correctReceiverPositions[i].getDimSize(2), receiverPositions[i].getDimSize(2));
         for(int j=0;j<correctReceiverPositions[i].getDataSize();++j)
         {
-            EXPECT_DOUBLE_AE(correctReceiverPositions[i][j], receiverPositions[i][j]);
+            EXPECT_float_AE(correctReceiverPositions[i][j], receiverPositions[i][j]);
         }
      }
 
-     EXPECT_DOUBLE_EQ(correctSenderNormals.size(), senderNormals.size());
+     EXPECT_FLOAT_EQ(correctSenderNormals.size(), senderNormals.size());
      for(int i=0;i<correctSenderNormals.size();++i)
      {
-        EXPECT_DOUBLE_EQ(correctSenderNormals[i].getDimSize(0), senderNormals[i].getDimSize(0));
-        EXPECT_DOUBLE_EQ(correctSenderNormals[i].getDimSize(1), senderNormals[i].getDimSize(1));
-        EXPECT_DOUBLE_EQ(correctSenderNormals[i].getDimSize(2), senderNormals[i].getDimSize(2));
+        EXPECT_FLOAT_EQ(correctSenderNormals[i].getDimSize(0), senderNormals[i].getDimSize(0));
+        EXPECT_FLOAT_EQ(correctSenderNormals[i].getDimSize(1), senderNormals[i].getDimSize(1));
+        EXPECT_FLOAT_EQ(correctSenderNormals[i].getDimSize(2), senderNormals[i].getDimSize(2));
         for(int j=0;j<correctSenderNormals[i].getDataSize();++j)
         {
-            EXPECT_DOUBLE_AE(correctSenderNormals[i][j], senderNormals[i][j]);
+            EXPECT_float_AE(correctSenderNormals[i][j], senderNormals[i][j]);
         }
      }          
 
-     EXPECT_DOUBLE_EQ(correctSenderPositions.size(), senderPositions.size());
+     EXPECT_FLOAT_EQ(correctSenderPositions.size(), senderPositions.size());
      for(int i=0;i<correctSenderPositions.size();++i)
      {
-        EXPECT_DOUBLE_EQ(correctSenderPositions[i].getDimSize(0), senderPositions[i].getDimSize(0));
-        EXPECT_DOUBLE_EQ(correctSenderPositions[i].getDimSize(1), senderPositions[i].getDimSize(1));
-        EXPECT_DOUBLE_EQ(correctSenderPositions[i].getDimSize(2), senderPositions[i].getDimSize(2));
+        EXPECT_FLOAT_EQ(correctSenderPositions[i].getDimSize(0), senderPositions[i].getDimSize(0));
+        EXPECT_FLOAT_EQ(correctSenderPositions[i].getDimSize(1), senderPositions[i].getDimSize(1));
+        EXPECT_FLOAT_EQ(correctSenderPositions[i].getDimSize(2), senderPositions[i].getDimSize(2));
         for(int j=0;j<correctSenderPositions[i].getDataSize();++j)
         {
-            EXPECT_DOUBLE_AE(correctSenderPositions[i][j], senderPositions[i][j]);
+            EXPECT_float_AE(correctSenderPositions[i][j], senderPositions[i][j]);
         }
      }  
 
     Aurora::Matrix sensChar = m.read("sensChar");
-    EXPECT_DOUBLE_EQ(geom.sensChar.getDataSize(), sensChar.getDataSize());
+    EXPECT_FLOAT_EQ(geom.sensChar.getDataSize(), sensChar.getDataSize());
     for(int i=0;i<geom.sensChar.getDataSize();++i)
     {
-        EXPECT_DOUBLE_AE(geom.sensChar.getData()[i], sensChar.getData()[i]);
+        EXPECT_float_AE(geom.sensChar.getData()[i], sensChar.getData()[i]);
     }
 
     Aurora::Matrix headTable = m.read("headTable");
-    EXPECT_DOUBLE_EQ(geom.headTable.getDataSize(), headTable.getDataSize());
+    EXPECT_FLOAT_EQ(geom.headTable.getDataSize(), headTable.getDataSize());
     for(int i=0;i<geom.headTable.getDataSize();++i)
     {
-        EXPECT_DOUBLE_AE(geom.headTable.getData()[i], headTable.getData()[i]);
+        EXPECT_float_AE(geom.headTable.getData()[i], headTable.getData()[i]);
     }    
 
     Aurora::Matrix minEmitter = m.read("minEmitter");
-    EXPECT_DOUBLE_EQ(geom.minEmitter.getDataSize(), minEmitter.getDataSize());
+    EXPECT_FLOAT_EQ(geom.minEmitter.getDataSize(), minEmitter.getDataSize());
     for(int i=0;i<geom.minEmitter.getDataSize();++i)
     {
-        EXPECT_DOUBLE_AE(geom.minEmitter.getData()[i], minEmitter.getData()[i]);
+        EXPECT_float_AE(geom.minEmitter.getData()[i], minEmitter.getData()[i]);
     }  
 
     Aurora::Matrix minReceiver = m.read("minReceiver");
-    EXPECT_DOUBLE_EQ(geom.minReceiver.getDataSize(), minReceiver.getDataSize());
+    EXPECT_FLOAT_EQ(geom.minReceiver.getDataSize(), minReceiver.getDataSize());
     for(int i=0;i<geom.minReceiver.getDataSize();++i)
     {
-        EXPECT_DOUBLE_AE(geom.minReceiver.getData()[i], minReceiver.getData()[i]);
+        EXPECT_float_AE(geom.minReceiver.getData()[i], minReceiver.getData()[i]);
     } 
 
     Aurora::Matrix minSize = m.read("minSize");
-    EXPECT_DOUBLE_EQ(geom.minSize.getDataSize(), minSize.getDataSize());
+    EXPECT_FLOAT_EQ(geom.minSize.getDataSize(), minSize.getDataSize());
     for(int i=0;i<geom.minSize.getDataSize();++i)
     {
-        EXPECT_DOUBLE_AE(geom.minSize.getData()[i], minSize.getData()[i]);
+        EXPECT_float_AE(geom.minSize.getData()[i], minSize.getData()[i]);
     }   
 
      Aurora::Matrix maxEmitter = m.read("maxEmitter");
-    EXPECT_DOUBLE_EQ(geom.maxEmitter.getDataSize(), maxEmitter.getDataSize());
+    EXPECT_FLOAT_EQ(geom.maxEmitter.getDataSize(), maxEmitter.getDataSize());
     for(int i=0;i<geom.maxEmitter.getDataSize();++i)
     {
-        EXPECT_DOUBLE_AE(geom.maxEmitter.getData()[i], maxEmitter.getData()[i]);
+        EXPECT_float_AE(geom.maxEmitter.getData()[i], maxEmitter.getData()[i]);
     }  
 
     Aurora::Matrix maxReceiver = m.read("maxReceiver");
-    EXPECT_DOUBLE_EQ(geom.maxReceiver.getDataSize(), maxReceiver.getDataSize());
+    EXPECT_FLOAT_EQ(geom.maxReceiver.getDataSize(), maxReceiver.getDataSize());
     for(int i=0;i<geom.maxReceiver.getDataSize();++i)
     {
-        EXPECT_DOUBLE_AE(geom.maxReceiver.getData()[i], maxReceiver.getData()[i]);
+        EXPECT_float_AE(geom.maxReceiver.getData()[i], maxReceiver.getData()[i]);
     } 
 
     Aurora::Matrix maxSize = m.read("maxSize");
-    EXPECT_DOUBLE_EQ(geom.maxSize.getDataSize(), maxSize.getDataSize());
+    EXPECT_FLOAT_EQ(geom.maxSize.getDataSize(), maxSize.getDataSize());
     for(int i=0;i<geom.maxSize.getDataSize();++i)
     {
-        EXPECT_DOUBLE_AE(geom.maxSize.getData()[i], maxSize.getData()[i]);
+        EXPECT_float_AE(geom.maxSize.getData()[i], maxSize.getData()[i]);
     }
 
     Aurora::Matrix maxSL = m.read("maxSL");
-    EXPECT_DOUBLE_EQ(geom.maxSL, maxSL[0]);         
+    EXPECT_FLOAT_EQ(geom.maxSL, maxSL[0]);         
 
     Aurora::Matrix maxSN = m.read("maxSN");
-    EXPECT_DOUBLE_EQ(geom.maxSN, maxSN[0]);   
+    EXPECT_FLOAT_EQ(geom.maxSN, maxSN[0]);   
 
     Aurora::Matrix maxRL = m.read("maxRL");
-    EXPECT_DOUBLE_EQ(geom.maxRL, maxRL[0]);    
+    EXPECT_FLOAT_EQ(geom.maxRL, maxRL[0]);    
 
     Aurora::Matrix maxRN = m.read("maxRN");
-    EXPECT_DOUBLE_EQ(geom.maxRN, maxRN[0]);
+    EXPECT_FLOAT_EQ(geom.maxRN, maxRN[0]);
 }
 
 TEST_F(Common_Test, getAscanBlock) {
@@ -232,64 +232,64 @@ TEST_F(Common_Test, getAscanBlock) {
     std::string dataPath = "/home/AScans_Data/volunteer_20230328/20230328T123237/";
     Parser parser(dataPath);
     auto ascanBlock = m.read("AscanBlock");
-    auto result = Recon::getAscanBlock(&parser, Aurora::Matrix::fromRawData(new double[1]{1}, 1), Aurora::Matrix::fromRawData(new double[1]{1}, 1),
-                                        Aurora::Matrix::fromRawData(new double[18]{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18}, 18),
-                                        Aurora::Matrix::fromRawData(new double[1]{1}, 1),
-                                        Aurora::Matrix::fromRawData(new double[18]{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18}, 18));
+    auto result = Recon::getAscanBlock(&parser, Aurora::Matrix::fromRawData(new float[1]{1}, 1), Aurora::Matrix::fromRawData(new float[1]{1}, 1),
+                                        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),
+                                        Aurora::Matrix::fromRawData(new float[1]{1}, 1),
+                                        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));
     for(int i=0; i<result.ascanBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(ascanBlock[i], result.ascanBlock[i]);
+        EXPECT_float_AE(ascanBlock[i], result.ascanBlock[i]);
     }
-    EXPECT_DOUBLE_EQ(ascanBlock.getDimSize(0), result.ascanBlock.getDimSize(0));
-    EXPECT_DOUBLE_EQ(ascanBlock.getDimSize(1), result.ascanBlock.getDimSize(1));
+    EXPECT_FLOAT_EQ(ascanBlock.getDimSize(0), result.ascanBlock.getDimSize(0));
+    EXPECT_FLOAT_EQ(ascanBlock.getDimSize(1), result.ascanBlock.getDimSize(1));
 
     auto gainBlock = m.read("gainBlock");
     for(int i=0; i<result.gainBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(gainBlock[i], result.gainBlock[i]);
+        EXPECT_float_AE(gainBlock[i], result.gainBlock[i]);
     }
-    EXPECT_DOUBLE_EQ(gainBlock.getDimSize(0), result.gainBlock.getDimSize(0));
-    EXPECT_DOUBLE_EQ(gainBlock.getDimSize(1), result.gainBlock.getDimSize(1));
+    EXPECT_FLOAT_EQ(gainBlock.getDimSize(0), result.gainBlock.getDimSize(0));
+    EXPECT_FLOAT_EQ(gainBlock.getDimSize(1), result.gainBlock.getDimSize(1));
 
     auto mpBlock = m.read("mpBlock");
     for(int i=0; i<result.mpBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(mpBlock[i], result.mpBlock[i]);
+        EXPECT_float_AE(mpBlock[i], result.mpBlock[i]);
     }
-    EXPECT_DOUBLE_EQ(mpBlock.getDimSize(0), result.mpBlock.getDimSize(0));
-    EXPECT_DOUBLE_EQ(mpBlock.getDimSize(1), result.mpBlock.getDimSize(1));
+    EXPECT_FLOAT_EQ(mpBlock.getDimSize(0), result.mpBlock.getDimSize(0));
+    EXPECT_FLOAT_EQ(mpBlock.getDimSize(1), result.mpBlock.getDimSize(1));
 
     auto rlBlock = m.read("rlBlock");
     for(int i=0; i<result.rlBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(rlBlock[i], result.rlBlock[i]);
+        EXPECT_float_AE(rlBlock[i], result.rlBlock[i]);
     }
-    EXPECT_DOUBLE_EQ(rlBlock.getDimSize(0), result.rlBlock.getDimSize(0));
-    EXPECT_DOUBLE_EQ(rlBlock.getDimSize(1), result.rlBlock.getDimSize(1));
+    EXPECT_FLOAT_EQ(rlBlock.getDimSize(0), result.rlBlock.getDimSize(0));
+    EXPECT_FLOAT_EQ(rlBlock.getDimSize(1), result.rlBlock.getDimSize(1));
 
     auto rnBlock = m.read("rnBlock");
     for(int i=0; i<result.rnBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(rnBlock[i], result.rnBlock[i]);
+        EXPECT_float_AE(rnBlock[i], result.rnBlock[i]);
     }
-    EXPECT_DOUBLE_EQ(rnBlock.getDimSize(0), result.rnBlock.getDimSize(0));
-    EXPECT_DOUBLE_EQ(rnBlock.getDimSize(1), result.rnBlock.getDimSize(1));
+    EXPECT_FLOAT_EQ(rnBlock.getDimSize(0), result.rnBlock.getDimSize(0));
+    EXPECT_FLOAT_EQ(rnBlock.getDimSize(1), result.rnBlock.getDimSize(1));
 
     auto slBlock = m.read("slBlock");
     for(int i=0; i<result.slBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(slBlock[i], result.slBlock[i]);
+        EXPECT_float_AE(slBlock[i], result.slBlock[i]);
     }
-    EXPECT_DOUBLE_EQ(slBlock.getDimSize(0), result.slBlock.getDimSize(0));
-    EXPECT_DOUBLE_EQ(slBlock.getDimSize(1), result.slBlock.getDimSize(1));
+    EXPECT_FLOAT_EQ(slBlock.getDimSize(0), result.slBlock.getDimSize(0));
+    EXPECT_FLOAT_EQ(slBlock.getDimSize(1), result.slBlock.getDimSize(1));
 
     auto snBlock = m.read("snBlock");
     for(int i=0; i<result.snBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(snBlock[i], result.snBlock[i]);
+        EXPECT_float_AE(snBlock[i], result.snBlock[i]);
     }
-    EXPECT_DOUBLE_EQ(snBlock.getDimSize(0), result.snBlock.getDimSize(0));
-    EXPECT_DOUBLE_EQ(snBlock.getDimSize(1), result.snBlock.getDimSize(1));
+    EXPECT_FLOAT_EQ(snBlock.getDimSize(0), result.snBlock.getDimSize(0));
+    EXPECT_FLOAT_EQ(snBlock.getDimSize(1), result.snBlock.getDimSize(1));
 }
 
 TEST_F(Common_Test, blockingGeometryInfos) {
@@ -312,34 +312,34 @@ TEST_F(Common_Test, blockingGeometryInfos) {
     auto receiverNormalBlock = m.read("receiverNormalBlock");
     for(int i=0; i<result.receiverNormalBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(receiverNormalBlock[i], result.receiverNormalBlock[i]);
+        EXPECT_float_AE(receiverNormalBlock[i], result.receiverNormalBlock[i]);
     }
     auto receiverPositionBlock = m.read("receiverPositionBlock");
     for(int i=0; i<result.receiverPositionBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(receiverPositionBlock[i], result.receiverPositionBlock[i]);
+        EXPECT_float_AE(receiverPositionBlock[i], result.receiverPositionBlock[i]);
     }
     auto senderNormalBlock = m.read("senderNormalBlock");
     for(int i=0; i<result.senderNormalBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(senderNormalBlock[i], result.senderNormalBlock[i]);
+        EXPECT_float_AE(senderNormalBlock[i], result.senderNormalBlock[i]);
     }
     auto senderPositionBlock = m.read("senderPositionBlock");
     for(int i=0; i<result.senderPositionBlock.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(senderPositionBlock[i], result.senderPositionBlock[i]);
+        EXPECT_float_AE(senderPositionBlock[i], result.senderPositionBlock[i]);
     }
 }
 
 TEST_F(Common_Test, removeDataFromArrays) {
-    Aurora::Matrix a = Aurora::Matrix::fromRawData(new double[8]{1,2,3,4,5,6,7,8}, 1,8);
-    Aurora::Matrix b = Aurora::Matrix::fromRawData(new double[8]{0,0,1,1,1,1,0,0}, 1,8);
+    Aurora::Matrix a = Aurora::Matrix::fromRawData(new float[8]{1,2,3,4,5,6,7,8}, 1,8);
+    Aurora::Matrix b = Aurora::Matrix::fromRawData(new float[8]{0,0,1,1,1,1,0,0}, 1,8);
     auto result = Recon::removeDataFromArrays(a, b);
-    EXPECT_DOUBLE_EQ(result.getDataSize(), 4);
-    EXPECT_DOUBLE_EQ(result[0], 3);
-    EXPECT_DOUBLE_EQ(result[1], 4);
-    EXPECT_DOUBLE_EQ(result[2], 5);
-    EXPECT_DOUBLE_EQ(result[3], 6);
+    EXPECT_FLOAT_EQ(result.getDataSize(), 4);
+    EXPECT_FLOAT_EQ(result[0], 3);
+    EXPECT_FLOAT_EQ(result[1], 4);
+    EXPECT_FLOAT_EQ(result[2], 5);
+    EXPECT_FLOAT_EQ(result[3], 6);
 }
 
 TEST_F(Common_Test, meshgrid) {
@@ -352,21 +352,21 @@ TEST_F(Common_Test, meshgrid) {
     auto yy = m.read("yy");
     auto zz = m.read("zz");
 
-    EXPECT_DOUBLE_AE(xx.getDataSize(), result.xx.getDataSize());
+    EXPECT_float_AE(xx.getDataSize(), result.xx.getDataSize());
     for(int i=0; i<xx.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(xx[i], result.xx[i]);
+        EXPECT_float_AE(xx[i], result.xx[i]);
     }
 
-    EXPECT_DOUBLE_AE(yy.getDataSize(), result.yy.getDataSize());
+    EXPECT_float_AE(yy.getDataSize(), result.yy.getDataSize());
     for(int i=0; i<yy.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(yy[i], result.yy[i]);
+        EXPECT_float_AE(yy[i], result.yy[i]);
     }
 
-    EXPECT_DOUBLE_AE(zz.getDataSize(), result.zz.getDataSize());
+    EXPECT_float_AE(zz.getDataSize(), result.zz.getDataSize());
     for(int i=0; i<zz.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(zz[i], result.zz[i]);
+        EXPECT_float_AE(zz[i], result.zz[i]);
     }        
 }
diff --git a/test/DICOM_Test.cpp b/test/DICOM_Test.cpp
new file mode 100644
index 0000000..3ec8161
--- /dev/null
+++ b/test/DICOM_Test.cpp
@@ -0,0 +1,39 @@
+#include <cstdio>
+#include <gtest/gtest.h>
+
+#include "Matrix.h"
+#include "Function3D.h"
+
+#include "Parser.h"
+#include "common/DICOMExporter.h"
+#include "config/config.h"
+
+class DICOM_Test : public ::testing::Test {
+protected:
+    static void SetUpCommonTester() {
+
+    }
+
+    static void TearDownTestCase() {
+    }
+
+    void SetUp() {
+    }
+
+    void TearDown() {
+    }
+};
+
+
+TEST_F(DICOM_Test, export) {
+
+    Recon::reflectParams::imageStartpoint = Aurora::Matrix::fromRawData(new float[3]{0, 0, 0}, 3, 1);
+    Recon::reflectParams::imageEndpoint = Aurora::Matrix::fromRawData(new float[3]{1, 1, 1}, 3, 1);
+
+    Parser dataParser("/home/krad/Storage/Raw/0020ceff713b_20240814T113556/");
+    GTEST_LOG_(INFO)<<"IS empty data:"<<(dataParser.getPatientData().getIsEmptyData()?"T":"F")<<", AccNo:"<<dataParser.getPatientData().getAccessionNumber()
+    <<", StudyUID:"<<dataParser.getPatientData().getStudyUID()<<", measurementID:"<<dataParser.getMetaData().getMeasurementID();
+    Recon::DICOMExporter exporter(dataParser.getPatientData(), dataParser.getMetaData());
+    exporter.setExportBasePath("/home/krad/workdir/UR/build/export/");
+    exporter.exportDICOM(Aurora::zeros(100,100,30), Recon::DICOMExporter::ImageType::ATT);
+}
\ No newline at end of file
diff --git a/test/DataFilter_Test.cpp b/test/DataFilter_Test.cpp
index 62e6a92..b9b0468 100644
--- a/test/DataFilter_Test.cpp
+++ b/test/DataFilter_Test.cpp
@@ -12,12 +12,12 @@
 
 
 
-inline double fourDecimalRound(double src){
+inline float fourDecimalRound(float src){
     return round(src*10000.0)/10000.0;
 }
 
-#define EXPECT_DOUBLE_AE(valueA,valueB)\
-    EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
+#define EXPECT_FLOAT_AE(valueA,valueB)\
+    EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
 
 class DataFilter_Test : public ::testing::Test {
 protected:
@@ -36,41 +36,41 @@ protected:
 };
 
 TEST_F(DataFilter_Test, filterTransmissionSensitivityMap) {
-    double *dataA = new double[4]{1, 1, 1, 1};
+    float *dataA = new float[4]{1, 1, 1, 1};
     auto slBlock  = Aurora::Matrix::fromRawData(dataA, 4, 1);
-    double *dataB = new double[4]{1, 1, 1, 1};
+    float *dataB = new float[4]{1, 1, 1, 1};
     auto snBlock  = Aurora::Matrix::fromRawData(dataB, 4, 1);
-    double *data3 = new double[4]{1, 1, 1, 2};
+    float *data3 = new float[4]{1, 1, 1, 2};
     auto rlBlock   = Aurora::Matrix::fromRawData(data3, 4, 1);
-    double *data4 = new double[4]{1, 2, 3, 1};
+    float *data4 = new float[4]{1, 2, 3, 1};
     auto rnBlock    = Aurora::Matrix::fromRawData(data4, 4, 1);
     std::vector<Aurora::Matrix> a66;
-    double *data6 = new double[6]{3, 2, 1, 9, 8, 6};
+    float *data6 = new float[6]{3, 2, 1, 9, 8, 6};
     auto sensData0 = Aurora::Matrix::fromRawData(data6, 3, 2, 1);
     a66.push_back(sensData0);
     auto result = Recon::filterTransmissionSensitivityMap(0.3, slBlock, snBlock, rlBlock, rnBlock, a66);
     EXPECT_EQ(4,result.getDataSize());
     for (size_t i = 0; i < 4; i++)
     {
-        EXPECT_DOUBLE_EQ(1.0,result.getData()[i]);
+        EXPECT_FLOAT_EQ(1.0,result.getData()[i]);
     }
     
 }
 
 TEST_F(DataFilter_Test, filterTransmissionAngle) {
-    double *dataA = new double[12]{0.99,0.99,0.99,0.99,0.10,0.10,0.10,0.10,0,0,0,0};
+    float *dataA = new float[12]{0.99,0.99,0.99,0.99,0.10,0.10,0.10,0.10,0,0,0,0};
     auto senderNormalBlock   = Aurora::transpose(Aurora::Matrix::fromRawData(dataA, 4, 3));
-    double *dataB = new double[12]{0.99,0.99,0.99,0.98,0.10,0.10,0.10,-0.15,0,0,0,0};
+    float *dataB = new float[12]{0.99,0.99,0.99,0.98,0.10,0.10,0.10,-0.15,0,0,0,0};
     auto receiverNormalBlock   = Aurora::transpose(Aurora::Matrix::fromRawData(dataB, 4, 3));
-    double angleLowerLimit = 10;
-    double angleUpperLimit = 180;
+    float angleLowerLimit = 10;
+    float angleUpperLimit = 180;
 
     auto result = Recon::filterTransmissionAngle(angleLowerLimit, angleUpperLimit, senderNormalBlock, receiverNormalBlock);
     EXPECT_EQ(4,result.getDataSize());
-    EXPECT_DOUBLE_EQ(0.0,result.getData()[0]);
-    EXPECT_DOUBLE_EQ(0.0,result.getData()[1]);
-    EXPECT_DOUBLE_EQ(0.0,result.getData()[2]);
-    EXPECT_DOUBLE_EQ(1.0,result.getData()[3]);
+    EXPECT_FLOAT_EQ(0.0,result.getData()[0]);
+    EXPECT_FLOAT_EQ(0.0,result.getData()[1]);
+    EXPECT_FLOAT_EQ(0.0,result.getData()[2]);
+    EXPECT_FLOAT_EQ(1.0,result.getData()[3]);
 }
 
 
@@ -88,12 +88,12 @@ TEST_F(DataFilter_Test, checkTofDetections) {
 
     for (size_t i = 0; i < result.valid.getDataSize(); i++)
     {
-        EXPECT_DOUBLE_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++)
     {
-        EXPECT_DOUBLE_AE(tofValues.getData()[i],result.tofValues.getData()[i])<< " :"<<i;
+        EXPECT_FLOAT_AE(tofValues.getData()[i],result.tofValues.getData()[i])<< " :"<<i;
     }
 }
 
@@ -106,13 +106,13 @@ TEST_F(DataFilter_Test, calculateSnr) {
 
     for (size_t i = 0; i < snrBlock.getDataSize(); i++)
     {
-        EXPECT_DOUBLE_AE(snrBlock.getData()[i],result.getData()[i]);
+        EXPECT_FLOAT_AE(snrBlock.getData()[i],result.getData()[i]);
     }
 }
 
 TEST_F(DataFilter_Test, findDefectTransmissionData) {
     MatlabReader m("/home/sun/testData/findDefectTransmissionData.mat");
-    double *dataA = new double[3]{1, std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()};
+    float *dataA = new float[3]{1, std::numeric_limits<float>::infinity(), -std::numeric_limits<float>::infinity()};
     auto SNRList = m.read("vsnrlist");
     auto SNRList2 = m.read("snrdifference");
     auto validOut = m.read("validOut");
@@ -122,19 +122,19 @@ TEST_F(DataFilter_Test, findDefectTransmissionData) {
     auto valid = valid1*valid2;
     for (size_t i = 0; i < valid.getDataSize(); i++)
     {
-        EXPECT_DOUBLE_AE(validOut[i],valid[i]);
+        EXPECT_FLOAT_AE(validOut[i],valid[i]);
     }
 }
 
 TEST_F(DataFilter_Test, filterReflectionData) {
-    auto receiverPositionBlock  = Aurora::transpose(Aurora::Matrix::fromRawData(new double[9]{-0.12,-0.12,-0.12,-0.01,-0.01,-0.01,0.03,0.03,0.04}, 3, 3));
-    auto senderPositionBlock = Aurora::transpose(Aurora::Matrix::fromRawData(new double[9]{-0.12,-0.12,-0.12,-0.01,-0.01,-0.01,0.03,0.03,0.03}, 3, 3));
-    auto senderNormalBlock  = Aurora::transpose(Aurora::Matrix::fromRawData(new double[9]{0.99,0.99,0.99,0.10,0.10,0.10,0,0,0}, 3, 3));
+    auto receiverPositionBlock  = Aurora::transpose(Aurora::Matrix::fromRawData(new float[9]{-0.12,-0.12,-0.12,-0.01,-0.01,-0.01,0.03,0.03,0.04}, 3, 3));
+    auto senderPositionBlock = Aurora::transpose(Aurora::Matrix::fromRawData(new float[9]{-0.12,-0.12,-0.12,-0.01,-0.01,-0.01,0.03,0.03,0.03}, 3, 3));
+    auto senderNormalBlock  = Aurora::transpose(Aurora::Matrix::fromRawData(new float[9]{0.99,0.99,0.99,0.10,0.10,0.10,0,0,0}, 3, 3));
     int constrictReflectionAngles = 1;
     auto result = Recon::filterReflectionData(receiverPositionBlock, senderPositionBlock, senderNormalBlock, constrictReflectionAngles);
     EXPECT_EQ(3, result.getDataSize());
-    EXPECT_DOUBLE_AE(result[0],1);
-    EXPECT_DOUBLE_AE(result[1],1);
-    EXPECT_DOUBLE_AE(result[2],0);
+    EXPECT_FLOAT_AE(result[0],1);
+    EXPECT_FLOAT_AE(result[1],1);
+    EXPECT_FLOAT_AE(result[2],0);
 
 }
diff --git a/test/Detection_Test.cpp b/test/Detection_Test.cpp
index b14718f..2218a2f 100644
--- a/test/Detection_Test.cpp
+++ b/test/Detection_Test.cpp
@@ -12,7 +12,7 @@
 
 
 
-inline double fourDecimalRound(double src){
+inline float fourDecimalRound(float src){
     return round(src*10000.0)/10000.0;
 }
 
@@ -48,7 +48,7 @@ TEST_F(Detection_Test, detectTofAndAttMex) {
     auto distBlockRef = m.read("distRefBlock");
     auto sosWaterBlock = Recon::temperatureToSoundSpeed(m.read("waterTempBlock"),"marczak");
     auto sosWaterRefBlock = Recon::temperatureToSoundSpeed(m.read("waterTempRefBlock"),"marczak");
-    double expectedSOSWater = 1.512677498767504e+03;
+    float expectedSOSWater = 1.512677498767504e+03;
 
     auto result = Recon::detectTofAndAttMex(
         AscanBlock, AscanRefBlock, distBlock, distBlockRef, sosWaterBlock,
@@ -87,7 +87,7 @@ TEST_F(Detection_Test, detectTofAndAtt) {
     auto distBlockRef = m.read("distRefBlock");
     auto sosWaterBlock = Recon::temperatureToSoundSpeed(m.read("waterTempBlock"), "marczak");
     auto sosWaterRefBlock = Recon::temperatureToSoundSpeed(m.read("waterTempRefBlock"), "marczak");
-    double expectedSOSWater = 1.512677498767504e+03;
+    float expectedSOSWater = 1.512677498767504e+03;
 
 
     auto result = Recon::detectTofAndAtt(
@@ -141,7 +141,7 @@ TEST_F(Detection_Test, detectAttVectorized) {
     MatlabReader m2("/home/krad/TestData/tofResult.mat");
     auto tof = m2.read("tof");
 
-    double expectedSOSWater = 1.511948131508464e+03;
+    float expectedSOSWater = 1.511948131508464e+03;
 
     auto result = Recon::detectAttVectorized(
         AscanBlock, AscanRefBlock, distBlockRef,sosWaterRefBlock,
@@ -157,8 +157,8 @@ TEST_F(Detection_Test, detectAttVectorized) {
 
 TEST_F(Detection_Test, calculateStarEndSearchPosition) {
 
-    auto distBlock   = Aurora::Matrix::fromRawData(new double[3]{0.22, 0.21, 0.11}, 3, 1);
-    auto sosOffsetBlock  = Aurora::Matrix::fromRawData(new double[3]{-0.8, 0, 0.9}, 3, 1);
+    auto distBlock   = Aurora::Matrix::fromRawData(new float[3]{0.22, 0.21, 0.11}, 3, 1);
+    auto sosOffsetBlock  = Aurora::Matrix::fromRawData(new float[3]{-0.8, 0, 0.9}, 3, 1);
 
     auto result = Recon::calculateStarEndSearchPosition(distBlock, 1400.0, 1650.0, 10000000, 9999, sosOffsetBlock,97.3,250);
     EXPECT_EQ(3,result.endSearch.getDataSize());
@@ -218,7 +218,7 @@ TEST_F(Detection_Test, detectTofVectorized) {
     auto distBlockRef = m.read("distRefBlock");
     auto sosWaterBlock = m.read("waterTempBlock");
     auto sosWaterRefBlock = m.read("waterTempRefBlock");
-    double expectedSOSWater = 1.511948131508464e+03;
+    float expectedSOSWater = 1.511948131508464e+03;
 
     auto result = Recon::detectTofVectorized(
         AscanBlock, AscanRefBlock, distBlock, distBlockRef, sosWaterBlock,
diff --git a/test/GetTransmissionData_Test.cpp b/test/GetTransmissionData_Test.cpp
index 4e005d1..f2c720b 100644
--- a/test/GetTransmissionData_Test.cpp
+++ b/test/GetTransmissionData_Test.cpp
@@ -21,7 +21,7 @@ using namespace Aurora;
 using namespace Recon;
 
 
-inline double fourDecimalRound(double src) {
+inline float fourDecimalRound(float src) {
     return round(src*10000.0)/10000.0;
 }
 
@@ -63,7 +63,7 @@ TEST_F(GetTransmissionData_Test, getTransmissionData) {
 
 
     // //getMeasurementMetaData
-    // double maxNumTAS = Aurora::max(auroraUnion(slList, rlList)).getData()[0];
+    // float maxNumTAS = Aurora::max(auroraUnion(slList, rlList)).getData()[0];
     // MeasurementInfo expInfo = loadMeasurementInfos(&dataParser);
     // TempInfo temp = getTemperatureInfo(&dataParser, maxNumTAS);
     // CEInfo ce = getCEInfo(&dataParser, expInfo);
@@ -84,7 +84,7 @@ TEST_F(GetTransmissionData_Test, getTransmissionData) {
     // motorPosAvailableRef = transformationInfo.motorPos;
     // if(transformationMatricesRef.isNull())
     // {
-    //     Matrix motorPos1 = Matrix::fromRawData(new double[1] {1}, 1);
+    //     Matrix motorPos1 = Matrix::fromRawData(new float[1] {1}, 1);
     //     transformationMatricesRef = getTransformationMatrix(&refParser, motorPos1).rotationMatrix;
     // }
     // else
@@ -112,12 +112,12 @@ TEST_F(GetTransmissionData_Test, getTransmissionData) {
 
     // if(expInfo.sampleRate != reflectParams::aScanReconstructionFrequency)
     // {
-    //     reflectParams::expectedAScanDataLength = ceil(expInfo.numberSamples * ((double)reflectParams::aScanReconstructionFrequency / expInfo.sampleRate));
+    //     reflectParams::expectedAScanDataLength = ceil(expInfo.numberSamples * ((float)reflectParams::aScanReconstructionFrequency / expInfo.sampleRate));
     // }
 
     // preComputes.matchedFilterRef = createMatchedFilter(ceRef.ce, ceRef.measuredCEUsed, reflectParams::findDefects, reconParams::removeOutliersFromCEMeasured, expInfo.Hardware);
 
-    // preComputes.timeInterval = (double)1 / reflectParams::aScanReconstructionFrequency;
+    // preComputes.timeInterval = (float)1 / reflectParams::aScanReconstructionFrequency;
     // preComputes.measuredCEUsed = ce.measuredCEUsed;
     // preComputes.measuredCE_TASIndices = ce.tasIndices;
     // preComputes.measuredCE_receiverIndices = ce.receiverIndices;
@@ -141,7 +141,7 @@ TEST_F(GetTransmissionData_Test, getTransmissionData) {
 
     // Matrix iMp;
     // Matrix mp_inter = intersect(motorPosAvailable, transParams::motorPos, iMp);
-    // double* mpRef_interData = Aurora::malloc(iMp.getDataSize());
+    // float* mpRef_interData = Aurora::malloc(iMp.getDataSize());
     // for(int i=0; i<iMp.getDataSize(); ++i)
     // {
     //     mpRef_interData[i] = motorPosAvailableRef[iMp[i] - 1];
diff --git a/test/Reconstruction_Test.cpp b/test/Reconstruction_Test.cpp
index c851b9f..b130d47 100644
--- a/test/Reconstruction_Test.cpp
+++ b/test/Reconstruction_Test.cpp
@@ -26,15 +26,15 @@
 
 
 
-inline double fourDecimalRound(double src){
+inline float fourDecimalRound(float src){
     return round(src*10000.0)/10000.0;
 }
 
-#define EXPECT_DOUBLE_AE(valueA,valueB)\
-    EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
+#define EXPECT_FLOAT_AE(valueA,valueB)\
+    EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
 
-    #define ASSERT_DOUBLE_AE(valueA,valueB)\
-    ASSERT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
+    #define ASSERT_FLOAT_AE(valueA,valueB)\
+    ASSERT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
 
 class Reconstruction_Test : public ::testing::Test {
 protected:
@@ -61,7 +61,7 @@ TEST_F(Reconstruction_Test, determineOptimalPulse) {
     auto f1 = m2.read("sincPeak_ft");
     for(size_t i=0; i<f1.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(f1[i], 0)<<"index:"<<i;
+        EXPECT_FLOAT_AE(f1[i], 0)<<"index:"<<i;
     }
 }
 
@@ -101,7 +101,7 @@ TEST_F(Reconstruction_Test, reconstructionSAFT) {
      auto result = Recon::recontructSAFT(Ascans, senderPos, receiverPos, mpIndex, 2, transRecos, Env);
     for(size_t i=0; i<result.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(result[i], EnvOut[i])<<"index:"<<i;
+        EXPECT_FLOAT_AE(result[i], EnvOut[i])<<"index:"<<i;
     }
 
 }
@@ -135,7 +135,7 @@ TEST_F(Reconstruction_Test, preprocessAScanBlockForReflection) {
     size_t size = result.AscanBlock.getDataSize();
     // for(size_t i=0; i<result.AscanBlock.getDataSize(); ++i)
     // {
-    //     ASSERT_DOUBLE_AE(f1[i], result[i])<<"index:"<<i;
+    //     ASSERT_FLOAT_AE(f1[i], result[i])<<"index:"<<i;
     // }
 }
 
@@ -154,7 +154,7 @@ TEST_F(Reconstruction_Test, reconstructArt) {
     auto result = Recon::reconstructArt(data, dataAtt, dims, senderList, receiverList, res, SOS_IN_WATER[0]);
     for(size_t i=0; i<f1.getDataSize(); ++i)
     {
-        ASSERT_DOUBLE_AE(f1[i], result.outSOS[i])<<"index:"<<i;
+        ASSERT_FLOAT_AE(f1[i], result.outSOS[i])<<"index:"<<i;
     }
 }
 
@@ -183,49 +183,49 @@ TEST_F(Reconstruction_Test, buildMatrix) {
     auto result = Recon::buildMatrix(senderList, receiverList, res, dims, false, potentialMap);
     for(size_t i=0; i<i1.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(i1[i] - 1, result.M.getColVector()[i]);
+        EXPECT_FLOAT_AE(i1[i] - 1, result.M.getColVector()[i]);
     }
 
     for(size_t i=0; i<j1.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(j1[i]- 1, result.M.getRowVector()[i]);
+        EXPECT_FLOAT_AE(j1[i]- 1, result.M.getRowVector()[i]);
     }
 
     for(size_t i=0; i<s1.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(s1[i], result.M.getValVector()[i]);
+        EXPECT_FLOAT_AE(s1[i], result.M.getValVector()[i]);
     }
 
 }
 
 TEST_F(Reconstruction_Test, calculateMinimalMaximalTransducerPositions) {
-    auto senderList  = Aurora::Matrix::fromRawData(new double[6]{1, 2, 3, 1, 2, 4}, 3, 2);
-    auto receiverList  = Aurora::Matrix::fromRawData(new double[6]{1, 8, 3, 1, 2, 1}, 3, 2);
+    auto senderList  = Aurora::Matrix::fromRawData(new float[6]{1, 2, 3, 1, 2, 4}, 3, 2);
+    auto receiverList  = Aurora::Matrix::fromRawData(new float[6]{1, 8, 3, 1, 2, 1}, 3, 2);
     auto result = Recon::calculateMinimalMaximalTransducerPositions(senderList,receiverList);
-    EXPECT_DOUBLE_EQ(1.0,result.getData()[0]);
-    EXPECT_DOUBLE_EQ(2,result.getData()[1]);
-    EXPECT_DOUBLE_EQ(1.0,result.getData()[2]);
-    EXPECT_DOUBLE_EQ(1.0,result.getData()[3]);
-    EXPECT_DOUBLE_EQ(8,result.getData()[4]);
-    EXPECT_DOUBLE_EQ(4,result.getData()[5]); 
+    EXPECT_FLOAT_EQ(1.0,result.getData()[0]);
+    EXPECT_FLOAT_EQ(2,result.getData()[1]);
+    EXPECT_FLOAT_EQ(1.0,result.getData()[2]);
+    EXPECT_FLOAT_EQ(1.0,result.getData()[3]);
+    EXPECT_FLOAT_EQ(8,result.getData()[4]);
+    EXPECT_FLOAT_EQ(4,result.getData()[5]); 
 }
 
 TEST_F(Reconstruction_Test, calculateResolution) {
-    auto ddims   = Aurora::Matrix::fromRawData(new double[6]{-0.1296,-0.1296,0.0185,0.1296,0.1295,0.1682}, 1, 6);
-    auto dims  = Aurora::Matrix::fromRawData(new double[3]{128,128,74}, 1, 3);
+    auto ddims   = Aurora::Matrix::fromRawData(new float[6]{-0.1296,-0.1296,0.0185,0.1296,0.1295,0.1682}, 1, 6);
+    auto dims  = Aurora::Matrix::fromRawData(new float[3]{128,128,74}, 1, 3);
     auto result  = Recon::calculateResolution(ddims, dims);
-    EXPECT_DOUBLE_AE(0.0020,result[0]);
-    EXPECT_DOUBLE_AE(0.0020,result[1]);
-    EXPECT_DOUBLE_AE(0.0021,result[2]);
+    EXPECT_FLOAT_AE(0.0020,result[0]);
+    EXPECT_FLOAT_AE(0.0020,result[1]);
+    EXPECT_FLOAT_AE(0.0021,result[2]);
 }
 
 TEST_F(Reconstruction_Test, getDimensions) {
-    auto ddims = Aurora::Matrix::fromRawData(new double[6]{-0.1296,-0.1296,0.0185,0.1296,0.1295,0.1682}, 1, 6);
-    double numPixelXY = 128;
+    auto ddims = Aurora::Matrix::fromRawData(new float[6]{-0.1296,-0.1296,0.0185,0.1296,0.1295,0.1682}, 1, 6);
+    float numPixelXY = 128;
     auto result  = Recon::getDimensions(numPixelXY,ddims);
-    EXPECT_DOUBLE_AE(128,result[0]);
-    EXPECT_DOUBLE_AE(128,result[1]);
-    EXPECT_DOUBLE_AE(74,result[2]);
+    EXPECT_FLOAT_AE(128,result[0]);
+    EXPECT_FLOAT_AE(128,result[1]);
+    EXPECT_FLOAT_AE(74,result[2]);
 }
 
 TEST_F(Reconstruction_Test, discretizePositions) {
@@ -240,34 +240,34 @@ TEST_F(Reconstruction_Test, discretizePositions) {
     auto result  = Recon::discretizePositions(senderList,receiverList,Recon::transParams::numPixelXY);
 
     
-    EXPECT_DOUBLE_AE(senderListResult.getDataSize(), result.senderCoordList.getDataSize());
+    EXPECT_FLOAT_AE(senderListResult.getDataSize(), result.senderCoordList.getDataSize());
     for(size_t i=0; i<senderListResult.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(senderListResult[i], result.senderCoordList[i]);
+        EXPECT_FLOAT_AE(senderListResult[i], result.senderCoordList[i]);
     }
 
-    EXPECT_DOUBLE_AE(receiverListResult.getDataSize(), result.receiverCoordList.getDataSize());
+    EXPECT_FLOAT_AE(receiverListResult.getDataSize(), result.receiverCoordList.getDataSize());
     for(size_t i=0; i<receiverListResult.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(receiverListResult[i], result.receiverCoordList[i]);
+        EXPECT_FLOAT_AE(receiverListResult[i], result.receiverCoordList[i]);
     }
 
-    EXPECT_DOUBLE_AE(dims.getDataSize(), result.dims.getDataSize());
+    EXPECT_FLOAT_AE(dims.getDataSize(), result.dims.getDataSize());
     for(size_t i=0; i<dims.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(dims[i], result.dims[i]);
+        EXPECT_FLOAT_AE(dims[i], result.dims[i]);
     }  
 
-    EXPECT_DOUBLE_AE(ddims.getDataSize(), result.ddims.getDataSize());
+    EXPECT_FLOAT_AE(ddims.getDataSize(), result.ddims.getDataSize());
     for(size_t i=0; i<ddims.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(ddims[i], result.ddims[i]);
+        EXPECT_FLOAT_AE(ddims[i], result.ddims[i]);
     } 
 
-    EXPECT_DOUBLE_AE(res.getDataSize(), result.res.getDataSize());
+    EXPECT_FLOAT_AE(res.getDataSize(), result.res.getDataSize());
     for(size_t i=0; i<res.getDataSize(); ++i)
     {
-        EXPECT_DOUBLE_AE(res[i], result.res[i]);
+        EXPECT_FLOAT_AE(res[i], result.res[i]);
     }           
 }
 
@@ -280,36 +280,36 @@ TEST_F(Reconstruction_Test, DGradient) {
     auto result = Recon::DGradient(x,1,2);
     for (size_t i = 0; i < result.getDataSize(); i++)
     {
-        EXPECT_DOUBLE_AE(result.getData()[i],y.getData()[i])<<"index:"<<i;
+        EXPECT_FLOAT_AE(result.getData()[i],y.getData()[i])<<"index:"<<i;
     }
 }
 
 TEST_F(Reconstruction_Test, correctPath) {
-    auto path  = Aurora::Matrix::fromRawData(new double[6]{1,1,10,9,1,1},2,3);
-    auto startPt = Aurora::Matrix::fromRawData(new double[3]{1, .5, 1}, 1, 3);
-    auto endPt = Aurora::Matrix::fromRawData(new double[3]{1, 10, 1}, 1, 3);
+    auto path  = Aurora::Matrix::fromRawData(new float[6]{1,1,10,9,1,1},2,3);
+    auto startPt = Aurora::Matrix::fromRawData(new float[3]{1, .5, 1}, 1, 3);
+    auto endPt = Aurora::Matrix::fromRawData(new float[3]{1, 10, 1}, 1, 3);
 
     Recon::correctPath(path,startPt,endPt);
     for (size_t i = 0; i < 10; i++)
     {
-        EXPECT_DOUBLE_EQ(path[i],1.0);
-        EXPECT_DOUBLE_EQ(path[i+10],1.0+i);
-        EXPECT_DOUBLE_EQ(path[i+20],1.0);
+        EXPECT_FLOAT_EQ(path[i],1.0);
+        EXPECT_FLOAT_EQ(path[i+10],1.0+i);
+        EXPECT_FLOAT_EQ(path[i+20],1.0);
     }
 }
 
 TEST_F(Reconstruction_Test,getPixelLengthApproximation){
-    auto startPt = Aurora::Matrix::fromRawData(new double[3]{1, 1, 1}, 1, 3);
-    auto endPt = Aurora::Matrix::fromRawData(new double[3]{4, 5, 6}, 1, 3);
-    auto res = Aurora::Matrix::fromRawData(new double[3]{.1, .1, .1}, 1, 3);
+    auto startPt = Aurora::Matrix::fromRawData(new float[3]{1, 1, 1}, 1, 3);
+    auto endPt = Aurora::Matrix::fromRawData(new float[3]{4, 5, 6}, 1, 3);
+    auto res = Aurora::Matrix::fromRawData(new float[3]{.1, .1, .1}, 1, 3);
     auto weight = Recon::getPixelLengthApproximation(startPt, endPt, res, 10);
-    EXPECT_DOUBLE_AE(weight[0],.0707);
+    EXPECT_FLOAT_AE(weight[0],.0707);
 }
 
 TEST_F(Reconstruction_Test,traceLine3D){
-    auto p1 = Aurora::Matrix::fromRawData(new double[3]{1, 10, 12}, 1, 3);
-    auto p2 = Aurora::Matrix::fromRawData(new double[3]{20, 2, 13}, 1, 3);
-    auto discretization = Aurora::Matrix::fromRawData(new double[3]{1, 1, 1}, 1, 3);
+    auto p1 = Aurora::Matrix::fromRawData(new float[3]{1, 10, 12}, 1, 3);
+    auto p2 = Aurora::Matrix::fromRawData(new float[3]{20, 2, 13}, 1, 3);
+    auto discretization = Aurora::Matrix::fromRawData(new float[3]{1, 1, 1}, 1, 3);
     auto result = Recon::traceLine3D(p1, p2, discretization);
     MatlabReader m("/home/krad/TestData/traceLine3D.mat");
 
@@ -317,45 +317,45 @@ TEST_F(Reconstruction_Test,traceLine3D){
     auto ds = m.read("ds");
     for (size_t i = 0; i < result.path.getDataSize(); i++)
     {
-        EXPECT_DOUBLE_AE(result.path.getData()[i],path[i])<<"index:"<<i;
+        EXPECT_FLOAT_AE(result.path.getData()[i],path[i])<<"index:"<<i;
     }
     for (size_t i = 0; i < result.ds.getDataSize(); i++)
     {
-        EXPECT_DOUBLE_AE(result.ds.getData()[i],ds[i])<<"index:"<<i;
+        EXPECT_FLOAT_AE(result.ds.getData()[i],ds[i])<<"index:"<<i;
     }
 }
 
 TEST_F(Reconstruction_Test,traceStraightRay){
-    auto p1 = Aurora::Matrix::fromRawData(new double[3]{1, 1, 1}, 1, 3);
-    auto p2 = Aurora::Matrix::fromRawData(new double[3]{5, 6, 7}, 1, 3);
-    auto res = Aurora::Matrix::fromRawData(new double[3]{.1, .1, .1}, 1, 3);
-    auto dmis = Aurora::Matrix::fromRawData(new double[3]{5, 10, 20}, 1, 3);
+    auto p1 = Aurora::Matrix::fromRawData(new float[3]{1, 1, 1}, 1, 3);
+    auto p2 = Aurora::Matrix::fromRawData(new float[3]{5, 6, 7}, 1, 3);
+    auto res = Aurora::Matrix::fromRawData(new float[3]{.1, .1, .1}, 1, 3);
+    auto dmis = Aurora::Matrix::fromRawData(new float[3]{5, 10, 20}, 1, 3);
     auto result = Recon::traceStraightRay(p1, p2, res, dmis);
     EXPECT_EQ(13, result.weighting.getDataSize());
-    EXPECT_DOUBLE_AE(result.weighting[0],0);
-    EXPECT_DOUBLE_AE(result.weighting[1],0.1462);
-    EXPECT_DOUBLE_AE(result.weighting[11],0.0292);
-    EXPECT_DOUBLE_AE(result.weighting[3],0.0439);
+    EXPECT_FLOAT_AE(result.weighting[0],0);
+    EXPECT_FLOAT_AE(result.weighting[1],0.1462);
+    EXPECT_FLOAT_AE(result.weighting[11],0.0292);
+    EXPECT_FLOAT_AE(result.weighting[3],0.0439);
     EXPECT_EQ(13, result.path.getDimSize(0));
     EXPECT_EQ(3, result.path.getDimSize(1));
-    EXPECT_DOUBLE_AE(result.path[0],1);
-    EXPECT_DOUBLE_AE(result.path[15],2);
-    EXPECT_DOUBLE_AE(result.path[30],3);
+    EXPECT_FLOAT_AE(result.path[0],1);
+    EXPECT_FLOAT_AE(result.path[15],2);
+    EXPECT_FLOAT_AE(result.path[30],3);
     EXPECT_EQ(13, result.pathLen);
 }
 
 TEST_F(Reconstruction_Test,traceStraightRayBresenham){
-    auto p1 = Aurora::Matrix::fromRawData(new double[3]{1, 1, 1}, 1, 3);
-    auto p2 = Aurora::Matrix::fromRawData(new double[3]{5, 6, 7}, 1, 3);
-    auto res = Aurora::Matrix::fromRawData(new double[3]{.1, .1, .1}, 1, 3);
+    auto p1 = Aurora::Matrix::fromRawData(new float[3]{1, 1, 1}, 1, 3);
+    auto p2 = Aurora::Matrix::fromRawData(new float[3]{5, 6, 7}, 1, 3);
+    auto res = Aurora::Matrix::fromRawData(new float[3]{.1, .1, .1}, 1, 3);
     auto result = Recon::traceStraightRayBresenham(p1, p2, res);
     EXPECT_EQ(1, result.weighting.getDataSize());
-    EXPECT_DOUBLE_AE(result.weighting[0],0.1462);
+    EXPECT_FLOAT_AE(result.weighting[0],0.1462);
     EXPECT_EQ(6, result.path.getDimSize(0));
     EXPECT_EQ(3, result.path.getDimSize(1));
-    EXPECT_DOUBLE_AE(result.path[0],1);
-    EXPECT_DOUBLE_AE(result.path[15],4);
-    EXPECT_DOUBLE_AE(result.path[7],2);
+    EXPECT_FLOAT_AE(result.path[0],1);
+    EXPECT_FLOAT_AE(result.path[15],4);
+    EXPECT_FLOAT_AE(result.path[7],2);
     EXPECT_EQ(6, result.pathLen);
 }
 
@@ -378,7 +378,7 @@ TEST_F(Reconstruction_Test,callTval3){
     Aurora::Sparse M(i1-1,j1-1,s1,734989,1196032);
     MatlabReader m2("/home/sun/testData/tval3gpu3d.mat");
     auto b = m2.read("b");
-    auto dims = Aurora::Matrix::fromRawData(new double[3]{128,128,73}, 1, 3);
+    auto dims = Aurora::Matrix::fromRawData(new float[3]{128,128,73}, 1, 3);
     auto result = Recon::callTval3(M, b, dims, 0,opt);
     auto outSOS = Recon::slownessToSOS(result, 1.498206569328594e+03) ;
     MatlabWriter w2("/home/krad/transmissionSOS111.mat");
diff --git a/test/Sensitivity_Test.cpp b/test/Sensitivity_Test.cpp
index 1d92c70..35574d7 100644
--- a/test/Sensitivity_Test.cpp
+++ b/test/Sensitivity_Test.cpp
@@ -5,15 +5,15 @@
 #include "transmissionReconstruction/dataFilter/sensitivityCalculations.h"
 #include "MatlabReader.h"
 
-inline double fourDecimalRound(double src){
+inline float fourDecimalRound(float src){
     return round(src*10000.0)/10000.0;
 }
 
-#define EXPECT_DOUBLE_AE(valueA,valueB)\
-    EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
+#define EXPECT_FLOAT_AE(valueA,valueB)\
+    EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
 
-#define ASSERT_DOUBLE_AE(valueA,valueB)\
-    ASSERT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
+#define ASSERT_FLOAT_AE(valueA,valueB)\
+    ASSERT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
 
 class Sensitivity_Test : public ::testing::Test {
 protected:
@@ -50,7 +50,7 @@ TEST_F(Sensitivity_Test, getSensitivity) {
     EXPECT_EQ(output.getDataSize(), sens.getDataSize());
     for (size_t i = 0; i < output.getDataSize(); i++)
     {
-        EXPECT_DOUBLE_AE(output.getData()[i],sens.getData()[i])<<", index:"<<i;
+        EXPECT_FLOAT_AE(output.getData()[i],sens.getData()[i])<<", index:"<<i;
     }
     
 }
@@ -70,7 +70,7 @@ TEST_F(Sensitivity_Test, precalcSensitivityForTAS){
     EXPECT_EQ(output.getDataSize(), sens.getDataSize());
     for (size_t i = 0; i < output.getDataSize(); i++)
     {
-        EXPECT_DOUBLE_AE(output.getData()[i],sens.getData()[i])<<", index:"<<i;
+        EXPECT_FLOAT_AE(output.getData()[i],sens.getData()[i])<<", index:"<<i;
     }
 }
 
@@ -96,7 +96,7 @@ TEST_F(Sensitivity_Test, combineSensitivity){
     {
         for (size_t j = 0; j < output[i].getDataSize(); j++)
         {
-            EXPECT_DOUBLE_AE(output[i].getData()[j],sens[i].getData()[j])<<"Matrix index:"<<i<<", value index:"<<j;
+            EXPECT_FLOAT_AE(output[i].getData()[j],sens[i].getData()[j])<<"Matrix index:"<<i<<", value index:"<<j;
             
         }
     }
@@ -116,7 +116,7 @@ TEST_F(Sensitivity_Test,precalcSensitivity){
     TASElements.receiverPositions = m3.read4d("receiverPositions");
     TASElements.receiverNormals = m3.read4d("receiverNormals");
     TASElements.sensChar = m.read("sensChar");
-    auto motorPos = Aurora::Matrix::fromRawData(new double[2]{1,2}, 2);
+    auto motorPos = Aurora::Matrix::fromRawData(new float[2]{1,2}, 2);
     auto output = precalcSensitivity(senderTASRange, senderElementRange, receiverTASRange, receiverElementRange, motorPos, TASElements);
     MatlabReader m2("/home/krad/TestData/precalcResult.mat");
     auto sens = m2.read4d("result");
@@ -127,7 +127,7 @@ TEST_F(Sensitivity_Test,precalcSensitivity){
     {
         for (size_t j = 0; j < output[i].getDataSize(); j++)
         {
-            EXPECT_DOUBLE_AE(output[i].getData()[j],sens[i].getData()[j])<<"Matrix index:"<<i<<", value index:"<<j;
+            EXPECT_FLOAT_AE(output[i].getData()[j],sens[i].getData()[j])<<"Matrix index:"<<i<<", value index:"<<j;
             
         }
     }
diff --git a/test/TransRecon_DataPreperation_Test.cpp b/test/TransRecon_DataPreperation_Test.cpp
index 42438ed..57b94ff 100644
--- a/test/TransRecon_DataPreperation_Test.cpp
+++ b/test/TransRecon_DataPreperation_Test.cpp
@@ -3,12 +3,12 @@
 #include "Function3D.h"
 #include "transmissionReconstruction/dataPreperation.h"
 
-inline double fourDecimalRound(double src){
+inline float fourDecimalRound(float src){
     return round(src*10000.0)/10000.0;
 }
 
-#define EXPECT_DOUBLE_AE(valueA,valueB)\
-    EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
+#define EXPECT_FLOAT_AE(valueA,valueB)\
+    EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB))
 
 class TransRecon_DataPreperation_Test : public ::testing::Test {
 protected:
@@ -27,39 +27,39 @@ protected:
 };
 
 TEST_F(TransRecon_DataPreperation_Test, distanceBetweenTwoPoints) {
-        double *dataA = new double[9]{1, 9, 4, 0, .01, 1.9, 300,22, -93};
+        float *dataA = new float[9]{1, 9, 4, 0, .01, 1.9, 300,22, -93};
         auto A = Aurora::Matrix::fromRawData(dataA, 3, 3);
-        double *dataB = new double[9]{2,3,3,2,2,1,3,3,-3};
+        float *dataB = new float[9]{2,3,3,2,2,1,3,3,-3};
         auto B = Aurora::Matrix::fromRawData(dataB, 3, 3);
         auto output =Recon::distanceBetweenTwoPoints(B,A);
         EXPECT_EQ(3, output.getDataSize());
-        EXPECT_DOUBLE_AE(6.1644,output.getData()[0]);
-        EXPECT_DOUBLE_AE(2.9614,output.getData()[1]);
-        EXPECT_DOUBLE_AE(310.9180,output.getData()[2]);
+        EXPECT_FLOAT_AE(6.1644,output.getData()[0]);
+        EXPECT_FLOAT_AE(2.9614,output.getData()[1]);
+        EXPECT_FLOAT_AE(310.9180,output.getData()[2]);
 }
 
 TEST_F(TransRecon_DataPreperation_Test, calculateWaterTemperature) {
 
         auto waterTempS = Aurora::ones(3, 2) * 25.9;
         auto waterTempR = Aurora::ones(4, 2) * 20 + 1.1;
-        double *xD = new double[6]{1, 2, 3, 1, 2, 3};
+        float *xD = new float[6]{1, 2, 3, 1, 2, 3};
         Aurora::Matrix sl(
-            std::shared_ptr<double>(xD, std::default_delete<double[]>()),
+            std::shared_ptr<float>(xD, std::default_delete<float[]>()),
             std::vector<int>{6});
-        xD = new double[6]{1, 1, 1, 1, 1, 1};
+        xD = new float[6]{1, 1, 1, 1, 1, 1};
         Aurora::Matrix rl(
-            std::shared_ptr<double>(xD, std::default_delete<double[]>()),
+            std::shared_ptr<float>(xD, std::default_delete<float[]>()),
             std::vector<int>{6});
-        xD = new double[6]{1, 1, 1, 2, 2, 2};
+        xD = new float[6]{1, 1, 1, 2, 2, 2};
         Aurora::Matrix mp(
-            std::shared_ptr<double>(xD, std::default_delete<double[]>()),
+            std::shared_ptr<float>(xD, std::default_delete<float[]>()),
             std::vector<int>{6});
 
         auto output = Recon::calculateWaterTemperature(waterTempS, waterTempR,
                                                        sl, rl, mp);
         EXPECT_EQ(6, output.getDataSize());
-        EXPECT_DOUBLE_AE(23.5, output.getData()[0]);
-        EXPECT_DOUBLE_AE(23.5, output.getData()[1]);
+        EXPECT_FLOAT_AE(23.5, output.getData()[0]);
+        EXPECT_FLOAT_AE(23.5, output.getData()[1]);
 }
 
 TEST_F(TransRecon_DataPreperation_Test, prepareAScansForTransmissionDetection){
@@ -68,6 +68,6 @@ TEST_F(TransRecon_DataPreperation_Test, prepareAScansForTransmissionDetection){
         auto result = Recon::prepareAScansForTransmissionDetection(aScanBlock,gainBlock);
         EXPECT_EQ(300, result.getDimSize(0));
         EXPECT_EQ(10, result.getDimSize(1));
-        EXPECT_DOUBLE_AE(0, result.getData()[0]);
+        EXPECT_FLOAT_AE(0, result.getData()[0]);
 }