Start getTransmissionData.

src/common/getGeometryInfo.h

@@ -24,6 +24,7 @@ namespace Recon
         std::vector<Aurora::Matrix> receiverNormals;
         std::vector<Aurora::Matrix> senderPositions;
         std::vector<Aurora::Matrix> receiverPositions;
+        std::vector<Aurora::Matrix> sensData;
     };
 
     GeometryInfo getGeometryInfo(const Aurora::Matrix& aMotorPos, const Aurora::Matrix& aTransformationMatrices,

src/common/temperatureCalculation/extractTasTemperature.cpp

@@ -0,0 +1,66 @@
+#include "extractTasTemperature.h"
+#include "Function2D.h"
+#include "Function.h"
+
+using namespace Aurora;
+
+namespace
+{
+    double getTemperatureForTas(const Matrix& aTasTemperature, double aTasNum, double aMotorPos,  const Matrix& aReferenceTemps,
+                                double aMinTemperature, double aMaxTemperature)
+    {
+        double result = NAN;
+        if(aMotorPos == 1)
+        {
+            for(int i=0; i<aTasTemperature.getDimSize(1); ++i)
+            {
+                if(aTasNum == aTasTemperature[2*i + 1])
+                {
+                    result = aTasTemperature[2*i];
+                }
+            }
+        }
+
+        if(result != result)
+        {
+            if(aReferenceTemps.getDimSize(1) >= aMotorPos)
+            {
+                result = mean(aReferenceTemps($,aMotorPos).toMatrix(), FunctionDirection::All, false)[0];
+            }
+            else
+            {
+                result = mean(aReferenceTemps, FunctionDirection::All, false)[0];
+            }
+        }
+
+        if (result < aMinTemperature)
+        {
+            return aMinTemperature;
+        }
+
+        if (result > aMaxTemperature)
+        {
+            return aMaxTemperature;
+        }
+
+        return result;
+    }
+}
+
+
+Matrix Recon::extractTasTemperature(const Matrix& aTasTemperature, const Matrix& aTasList, const Matrix& aMotorPosList, const Matrix& aDefaultTemps,
+                             double aMinTemperature, double aMaxTemperature)
+{
+    size_t resultSize = aTasList.getDataSize() * aMotorPosList.getDataSize();
+    double* resultData = Aurora::malloc(resultSize);
+    for(int i=0; i<aMotorPosList.getDataSize(); ++i)
+    {
+        for(int j=0; j<aTasList.getDataSize(); ++j)
+        {
+            resultData[i*aTasList.getDataSize() + j] = getTemperatureForTas(aTasTemperature, aTasList[j], aMotorPosList[i], aDefaultTemps, aMinTemperature, aMaxTemperature);
+        }
+    }
+    Matrix result = Matrix::New(resultData, aTasList.getDataSize(), aMotorPosList.getDataSize());
+    result.printf();
+    return result;
+}

src/common/temperatureCalculation/extractTasTemperature.h

@@ -0,0 +1,20 @@
+#ifndef EXTRACT_TAS_TEMPERATURE_H
+#define EXTRACT_TAS_TEMPERATURE_H
+
+#include "Matrix.h"
+
+namespace Recon
+{
+    struct TasTemps
+    {
+        Aurora::Matrix waterTempPreCalc_rl;
+        Aurora::Matrix waterTempPreCalc_sl;
+        Aurora::Matrix waterTempRefPreCalc_rl;
+        Aurora::Matrix waterTempRefPreCalc_sl;
+    };
+     
+    Aurora::Matrix extractTasTemperature(const Aurora::Matrix& aTasTemperature, const Aurora::Matrix& aTasList, const Aurora::Matrix& aMotorPosList, 
+                                         const Aurora::Matrix& aDefaultTemps,double aMinTemperature, double aMaxTemperature);
+}
+
+#endif

src/config/config.h

@@ -120,8 +120,8 @@ namespace Recon
         static int numPixelXY = 128;
         static double offsetElectronic = 5.2e-7;
         static int aScanReconstructionFrequency = 10000000;
-        static int minTemperature = 15;
-        static int maxTemperature = 40;
+        static double minTemperature = 15;
+        static double maxTemperature = 40;
         //transParams.detection
         static int forceRedetect = 0;
         static int saveDetection = 0;

src/transmissionReconstruction/dataFilter/sensitivityCalculations.cpp

@@ -189,7 +189,7 @@ precalcSensitivity(const Aurora::Matrix &aVSenderTASRange,
                    const Aurora::Matrix &aVSenderElementRange,
                    const Aurora::Matrix &aVReceiverTASRange,
                    const Aurora::Matrix &aVReceiverElementRange,
-                   const Aurora::Matrix &aVMotorPos, const geo &aTASElements) {
+                   const Aurora::Matrix &aVMotorPos, const GeometryInfo &aTASElements) {
   size_t dim = aTASElements.receiverPositions[0].getDimSize(0);
   size_t pos1Idx = (int)aVMotorPos.getData()[0] - 1;
   auto receiverPositions = aTASElements.receiverPositions[pos1Idx];

src/transmissionReconstruction/dataFilter/sensitivityCalculations.h

@@ -3,18 +3,9 @@
 #include <vector>
 
 #include "Matrix.h"
+#include "src/common/getGeometryInfo.h"
 
 namespace Recon {
-struct geo {
-  //[471][4]
-  Aurora::Matrix headTable;
-  //[181][181]
-  Aurora::Matrix sensChar;
-  std::vector<Aurora::Matrix> senderNormals;
-  std::vector<Aurora::Matrix> receiverNormals;
-  std::vector<Aurora::Matrix> senderPositions;
-  std::vector<Aurora::Matrix> receiverPositions;
-};
 
 Aurora::Matrix getSensitivity(const Aurora::Matrix &aMSensmap,
                               Aurora::Matrix aVSenderNormal,
@@ -39,6 +30,6 @@ precalcSensitivity(const Aurora::Matrix &aVSenderTASRange,
                    const Aurora::Matrix &aVReceiverTASRange,
                    const Aurora::Matrix &aVReceiverElementRange,
                    const Aurora::Matrix &aVMotorPos,
-                   const geo &aTASElements);
+                   const GeometryInfo &aTASElements);
 } // namespace Recon
 #endif // __SENSITIVITYCALCULATIONS_H__

src/transmissionReconstruction/detection/getTransmissionData.cpp

@@ -0,0 +1,33 @@
+#include "getTransmissionData.h"
+#include "../../config/config.h"
+#include "src/common/temperatureCalculation/extractTasTemperature.h"
+#include "src/transmissionReconstruction/dataFilter/sensitivityCalculations.h"
+
+#include "Matrix.h"
+#include <cstddef>
+
+using namespace Recon;
+using namespace Aurora;
+
+void Recon::getTransmissionData(const Aurora::Matrix& aMotorPos, const Aurora::Matrix& aMotoPosRef, const Aurora::Matrix& aSlList,
+                                const Aurora::Matrix& aSnList, const Aurora::Matrix& aRlList, const Aurora::Matrix& aRnList,
+                                const TempInfo& aTemp, const TempInfo& aTempRef, GeometryInfo& aGeom,
+                                GeometryInfo& aGeomRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef,
+                                const PreComputes& aPreComputes)
+{
+    //推测是已经完成过透射重建并从完成的透射重建读取数据，但下方读取后数据又被覆盖
+    //暂不考虑此逻辑运行
+    // if transParams.detection.forceRedetect == 0 && exist(transParams.pathSaveDetection, 'dir') && size(dir(transParams.pathSaveDetection), 1) > 2 % i.e. detection folder exists and is not empty
+    //     % Load transmission detection data
+    //     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);
+    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.sensChar = precalcSensitivity(aSlList, aSnList, aRlList, aRnList, aMotorPos, const geo &aTASElements)
+
+
+}

src/transmissionReconstruction/detection/getTransmissionData.h

@@ -0,0 +1,17 @@
+#ifndef GET_TRANSMISSION_DATA_H
+#define GET_TRANSMISSION_DATA_H
+
+#include "Matrix.h"
+#include "../../common/getMeasurementMetaData.h"
+#include "src/common/getGeometryInfo.h"
+
+namespace Recon
+{
+    void getTransmissionData(const Aurora::Matrix& aMotorPos, const Aurora::Matrix& aMotoPosRef, const Aurora::Matrix& aSlList,
+                             const Aurora::Matrix& aSnList, const Aurora::Matrix& aRlList, const Aurora::Matrix& aRnList,
+                             const TempInfo& aTemp, const TempInfo& aTempRef, GeometryInfo& aGeom,
+                             GeometryInfo& aGeomRef, const MeasurementInfo& aExpInfo, const MeasurementInfo& aExpInfoRef,
+                             const PreComputes& aPreComputes);
+}
+
+#endif