diff --git a/src/MatLab/MatlabCreatorVariableWindowPrivate.cpp b/src/MatLab/MatlabCreatorVariableWindowPrivate.cpp
new file mode 100644
index 0000000..4800cda
--- /dev/null
+++ b/src/MatLab/MatlabCreatorVariableWindowPrivate.cpp
@@ -0,0 +1,1020 @@
+#include "MatlabCreatorVariableWindowPrivate.h"
+
+#include "Helper/FileListHelper.h"
+#include "Helper/ThreadHelper.h"
+#include "Helper/DirHelper.h"
+#include "Helper/MatlabHelper.h"
+#include "Data/Hardwareinfomation.h"
+#include "Data/OneTasAScanData.h"
+#include "Data/AScanData.h"
+#include "Data/CEMeasuredData.h"
+#include "Data/GeometryIndex.h"
+#include "Data/ElementIndex.h"
+#include "Data/CEData.h"
+#include "Data/MetaData.h"
+#include "Data/MovementData.h"
+#include "Data/TemperatureData.h"
+#include "Data/PatientData.h"
+#include "Mapper/MapperDataBase.h"
+#include "MatlabOpener.h"
+#include "Data/TasElementIndex.h"
+#include "ShotList/ShotList.h"
+#include "Parser.h"
+
+#include <vector>
+#include <queue>
+#include <thread>
+#include <iostream>
+#include <condition_variable>
+#include <fstream>
+#include <algorithm>
+#include <string.h>
+#include <cmath>
+
+namespace
+{
+    struct CreateMatSturct
+    {
+        std::shared_ptr<Parser> mParser;
+        std::string mFileName;
+        std::shared_ptr<double> mAScanData;
+        std::shared_ptr<double> mAmplificationData;
+    };
+
+    double progress = 0;
+
+    std::queue<CreateMatSturct> PRODUCER_DATAS;
+    std::mutex PRODUCER_MUTEX;
+    std::condition_variable PRODUCER_CONDITION;
+    int START_POINT[128][128];
+    unsigned long long VARIABLE_WINDOW_ASCAN_LENGTH;
+
+    bool initStartPoint()
+    {
+        std::ifstream infile("startPoint.txt");
+        if (!infile)
+        {
+            return false;
+        }
+        std::string line;
+        int row = 0, col = 0;
+        while (getline(infile, line))
+        {
+            line.erase(remove(line.begin(), line.end(), ','), line.end());
+            int indexValue = stoi(line) - 1;
+            START_POINT[row][col] = indexValue < 0 ? 0 : indexValue;
+            col++;
+            if (col == 128)
+            {
+                col = 0;
+                row++;
+            }
+        }
+        return true;
+    }
+
+    double calcuteAverageOfAscan(const double* aAscan, size_t aSize)
+    {
+        double sum = 0.0;
+        for (unsigned int i = 0; i < aSize; ++i)
+        {
+            sum += aAscan[i];
+        }
+        return  sum/aSize;
+    }
+
+    double convertfp16tofloat(uint16_t f16)
+    {
+        unsigned int sign, exp, fraction,hiden_bit=0;
+        double val;
+
+        sign = (f16 & 0x8000) >> 15;
+        exp = (f16 & 0x7800) >> 11;
+        fraction = f16 & 0x7ff;
+
+        if((sign==1 && exp==0) || (sign==0 && exp!=0))
+        {
+            hiden_bit = 0x800;
+        }
+        if(exp>0)exp--;
+        val = (int32_t)((fraction+hiden_bit+(0xFFFFF000*sign))<<(exp));
+        return val;
+    }
+
+    std::string getTasFolderName(unsigned short aNum)
+    {
+        if (aNum < 10)
+        {
+            return "TAS00" + std::to_string(aNum);
+        }
+        else if(aNum >= 10 && aNum < 100)
+        {
+            return "TAS0" + std::to_string(aNum);
+        }
+        else
+        {
+            return "TAS" + std::to_string(aNum);
+        }
+    }
+
+    std::string getMotorPositionFolderName(unsigned short aNum)
+    {
+        return "TASRotation0" + std::to_string(aNum);
+    }
+
+    std::string getCEMeasureFolderName()
+    {
+        return "TASRotation00";
+    }
+
+    std::string getMatFileName(unsigned short aNum)
+    {
+        if (aNum < 10)
+        {
+            return "Emitter0" + std::to_string(aNum) + ".mat";
+        }
+        else
+        {
+            return "Emitter" + std::to_string(aNum) + ".mat";
+        }
+    }
+}
+
+MatlabCreatorVariableWindowPrivate::MatlabCreatorVariableWindowPrivate(const std::string& aDirectoryPath)
+    : mDirectoryPath(FileListHelper::fixPathSlash(aDirectoryPath))
+    , mFileList(FileListHelper::getFileList(mDirectoryPath))
+{
+    DirHelper::checkPathSlash(mDirectoryPath);
+}
+
+void MatlabCreatorVariableWindowPrivate::setDirectoryPath(const std::string& aDirectoryPath)
+{
+    mDirectoryPath = FileListHelper::fixPathSlash(aDirectoryPath);
+    DirHelper::checkPathSlash(mDirectoryPath);
+    mFileList = FileListHelper::getFileList(mDirectoryPath);
+}
+
+bool MatlabCreatorVariableWindowPrivate::createKITMat(const std::string& aOutputPath)
+{
+    if(!initStartPoint())
+    {
+        return false;
+    }
+
+    progress = 0;
+    if(mFileList.size() == 0)
+    {
+        return false;
+    }
+    std::shared_ptr<Parser> parser(new Parser(mDirectoryPath));
+    std::shared_ptr<ShotList> shotList = parser->getShotList();
+    if(!shotList->isValid())
+    {
+        return false;
+    }
+    VARIABLE_WINDOW_ASCAN_LENGTH = parser->getDataLength() + 2397 - 1;
+    unsigned int fileCount = static_cast<unsigned int>(mFileList.size());
+    unsigned int tasCount = shotList->getTasSize();
+    unsigned int threadCount = ThreadHelper::getCreateMatFileThread(tasCount,fileCount);
+    unsigned int threadRemainder = tasCount % threadCount;
+    unsigned int tasOffSet = (tasCount - threadRemainder) / threadCount;
+    if(threadRemainder != 0)
+    {
+        ++tasOffSet;
+    }
+    unsigned int tasNum = 0;
+    std::vector<std::shared_ptr<std::thread>> threads(static_cast<size_t>(threadCount));
+
+    std::string dirPath = aOutputPath;
+    DirHelper dir;
+    if(!dir.exists(dirPath))
+    {
+        dir.mkdir(dirPath);
+    }
+
+    for(unsigned int i=0;i<threadCount;++i)
+    {
+        if(i == threadRemainder && threadRemainder!=0)
+        {
+            --tasOffSet;
+        }
+        threads[i] = std::shared_ptr<std::thread>(new std::thread(&MatlabCreatorVariableWindowPrivate::createKITMatInThread, this, parser->clone(), tasNum, tasOffSet, dirPath));
+        tasNum += tasOffSet;
+    }
+    for(unsigned int i=0; i< threadCount; ++i)
+    {
+        threads[i]->join();
+    }
+    createCEMat(parser,dirPath);
+    createInfoMat(parser,dirPath);
+    createPatDataMat(parser,dirPath);
+    createTasTempMat(parser,dirPath);
+    createJumoTempMat(parser,dirPath);
+    createMovementsMat(parser,dirPath);
+    createCEMeasuredMat(parser,dirPath);
+    createTasTemCompMat(parser,dirPath);
+    createMeasurementRotationMat(parser,dirPath);
+
+    std::cout<<std::endl;
+    return true;
+}
+
+void MatlabCreatorVariableWindowPrivate::createKITMatInThread(std::shared_ptr<Parser> aParser, unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath)
+{
+    std::thread producerThread = std::thread(&MatlabCreatorVariableWindowPrivate::producerThreadFunction, this, aParser, aStartTasNum, aTasCount, aOutputPath);
+    ShotList* shotList = aParser->getShotList().get();
+    for(unsigned short t=aStartTasNum;t<aStartTasNum+aTasCount;++t)
+    {
+        //Motorposition
+        for(unsigned short m=0;m<shotList->getMotorPositionSize();++m)
+        {
+            for(unsigned short e=0;e<shotList->getElementSize();++e)
+            {
+                std::unique_lock<std::mutex> lock(PRODUCER_MUTEX);
+                PRODUCER_CONDITION.wait(lock, []{return !PRODUCER_DATAS.empty();});
+                std::shared_ptr<Parser> parser = PRODUCER_DATAS.front().mParser;
+                std::string fileName = PRODUCER_DATAS.front().mFileName;
+                std::shared_ptr<double> ascanData = PRODUCER_DATAS.front().mAScanData;
+                std::shared_ptr<double> amplificationData = PRODUCER_DATAS.front().mAmplificationData;
+                PRODUCER_DATAS.pop();
+                lock.unlock();
+                createEmitterMat(parser,fileName,ascanData,amplificationData);
+            }
+        }
+        //CEMeasure
+        if(shotList->hasCEMeasured())
+        {
+            std::unique_lock<std::mutex> lock(PRODUCER_MUTEX);
+            PRODUCER_CONDITION.wait(lock, []{return !PRODUCER_DATAS.empty();});
+            std::shared_ptr<Parser> parser = PRODUCER_DATAS.front().mParser;
+            std::string fileName = PRODUCER_DATAS.front().mFileName;
+            std::shared_ptr<double> ascanData = PRODUCER_DATAS.front().mAScanData;
+            std::shared_ptr<double> amplificationData = PRODUCER_DATAS.front().mAmplificationData;
+            PRODUCER_DATAS.pop();
+            lock.unlock();
+            createEmitterMat(parser,fileName,ascanData,amplificationData);
+        }
+        ++progress;
+        std::cout<<"\r\033[K"<<std::flush;
+        std::cout<< "progress: \033[41m\033[1m " + std::to_string(progress/1.28) + "%\033[0m" <<std::flush;
+    }
+    producerThread.join();
+}
+
+void MatlabCreatorVariableWindowPrivate::producerThreadFunction(std::shared_ptr<Parser> aParser, unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath)
+{
+    std::string dirPath = aOutputPath;
+    DirHelper dir;
+    ShotList* shotList = aParser->getShotList().get();
+    for(unsigned short t=aStartTasNum;t<aStartTasNum+aTasCount;++t)
+    {
+        std::string tasFloder = dirPath + SLASH_CHAR + getTasFolderName(shotList->getTasValue(t));
+        if(!dir.exists(tasFloder))
+        {
+            dir.mkdir(tasFloder);
+        }
+        OneTasAScanData oneTasAscan = aParser->getOneTasAscanDataOfMotorPosition(shotList->getTasValue(t));
+        //Motorposition
+        for(unsigned short m=0;m<shotList->getMotorPositionSize();++m)
+        {
+            std::string motorpositionFolder = tasFloder + SLASH_CHAR + getMotorPositionFolderName(shotList->getMotorPositionValue(m));
+            if(!dir.exists(motorpositionFolder))
+            {
+                dir.mkdir(motorpositionFolder);
+            }
+            for(unsigned short e=0;e<shotList->getElementSize();++e)
+            {
+                unsigned short element = shotList->getElementValue(e);
+                std::shared_ptr<double> ascanData = std::shared_ptr<double>(new double[VARIABLE_WINDOW_ASCAN_LENGTH * RECEIVE_ELEMENT_COUNT],std::default_delete<double[]>());
+                memset(ascanData.get(), 0, sizeof(double) * VARIABLE_WINDOW_ASCAN_LENGTH * RECEIVE_ELEMENT_COUNT);
+                std::shared_ptr<double> amplificationData = std::shared_ptr<double>(new double[RECEIVE_ELEMENT_COUNT],std::default_delete<double[]>());
+                getAScanOfMPAndAmplification(aParser,shotList,oneTasAscan,ascanData,amplificationData,element,MotorPosition(shotList->getMotorPositionValue(m)));
+                std::string fileName = motorpositionFolder + SLASH_CHAR + getMatFileName(element);
+                std::unique_lock<std::mutex> lock(PRODUCER_MUTEX);
+                PRODUCER_DATAS.push({aParser,fileName,ascanData,amplificationData});
+                lock.unlock();
+                PRODUCER_CONDITION.notify_one();
+                //createEmitterMat(aParser,fileName,ascanData,amplificationData);
+            }
+        }
+        //CEMeasure
+        if(shotList->hasCEMeasured())
+        {
+            std::string cemeasureFolder = tasFloder + SLASH_CHAR + getCEMeasureFolderName();
+            if(!dir.exists(cemeasureFolder))
+            {
+                dir.mkdir(cemeasureFolder);
+            }
+            oneTasAscan = aParser->getOneTasAscanDataOfCEMeasured(shotList->getTasValue(t));
+            std::shared_ptr<double> ascanData = std::shared_ptr<double>(new double[VARIABLE_WINDOW_ASCAN_LENGTH * RECEIVE_ELEMENT_COUNT],std::default_delete<double[]>());
+            memset(ascanData.get(), 0, sizeof(double) * VARIABLE_WINDOW_ASCAN_LENGTH * RECEIVE_ELEMENT_COUNT);
+            std::shared_ptr<double> amplificationData = std::shared_ptr<double>(new double[RECEIVE_ELEMENT_COUNT],std::default_delete<double[]>());
+            getAScanOfCEAndAmplification(aParser,shotList,oneTasAscan,ascanData,amplificationData);
+            std::string fileName = cemeasureFolder + SLASH_CHAR + getMatFileName(0);
+            std::unique_lock<std::mutex> lock(PRODUCER_MUTEX);
+            PRODUCER_DATAS.push({aParser,fileName,ascanData,amplificationData});
+            lock.unlock();
+            PRODUCER_CONDITION.notify_one();
+            //createEmitterMat(aParser,fileName,ascanData,amplificationData);
+        }
+    }
+}
+
+void MatlabCreatorVariableWindowPrivate::createEmitterMat(std::shared_ptr<Parser> aParser,const std::string& aFileName,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData)
+{
+    std::shared_ptr<unsigned short> mapperArrayPointer = MapperDataBase::getMapperArray();
+    std::string measurementID = aParser->getMetaData().getMeasurementID();
+    size_t measurementDims[2] = {1,measurementID.size()};
+    size_t ascanDims[2] = {VARIABLE_WINDOW_ASCAN_LENGTH,RECEIVE_ELEMENT_COUNT};
+    size_t amplificationDims[2] = {1,RECEIVE_ELEMENT_COUNT};
+    ReceiverIndicesPointer receiverIndicesPointer = aParser->getMetaData().getReceiverIndices();
+    size_t receiverIndicesDims[2] = {receiverIndicesPointer.getLength(),1};
+    double* receiverIndicesData = new double[receiverIndicesPointer.getLength()];
+    std::copy(receiverIndicesPointer.get(),receiverIndicesPointer.get() + receiverIndicesPointer.getLength(), receiverIndicesData);
+    TasIndicesPointer tasIndicesPointer = aParser->getMetaData().getTasIndices();
+    size_t tasIndicesDims[2] = {tasIndicesPointer.getLength(),1};
+    double* tasIndicesData = new double[tasIndicesPointer.getLength()];
+    std::copy(tasIndicesPointer.get(),tasIndicesPointer.get() + tasIndicesPointer.getLength(), tasIndicesData);
+    mat_t* matfp = nullptr;
+    matfp = Mat_CreateVer(aFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+    if ( nullptr == matfp )
+    {
+        return;
+    }
+    matvar_t* measurementIdVar = Mat_VarCreate("MeasurementID", MAT_C_CHAR,MAT_T_INT8,2,measurementDims,const_cast<char*>(measurementID.c_str()),0);
+    matvar_t* ascanVar = Mat_VarCreate("AScans", MAT_C_DOUBLE,MAT_T_DOUBLE,2,ascanDims,aAScanData.get(),0);
+    matvar_t* amplificationVar = Mat_VarCreate("Amplification", MAT_C_DOUBLE,MAT_T_DOUBLE,2,amplificationDims,aAmplificationData.get(),0);
+    matvar_t* receiverIndicesVar = Mat_VarCreate("receiverIndices",MAT_C_DOUBLE,MAT_T_DOUBLE,2,receiverIndicesDims,receiverIndicesData,0);
+    delete[] receiverIndicesData;
+    matvar_t* tasIndicesVar = Mat_VarCreate("TASIndices",MAT_C_DOUBLE,MAT_T_DOUBLE,2,tasIndicesDims,tasIndicesData,0);
+    delete[] tasIndicesData;
+    Mat_VarWrite(matfp,measurementIdVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,ascanVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,amplificationVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,receiverIndicesVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,tasIndicesVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(measurementIdVar);
+    Mat_VarFree(ascanVar);
+    Mat_VarFree(amplificationVar);
+    Mat_VarFree(receiverIndicesVar);
+    Mat_VarFree(tasIndicesVar);
+    Mat_Close(matfp);
+    return;
+}
+
+void MatlabCreatorVariableWindowPrivate::getAScanOfCEAndAmplification(std::shared_ptr<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData)
+{
+    std::shared_ptr<unsigned short> mapperArrayPointer = MapperDataBase::getMapperArray();
+    for(unsigned int muxIndex = 0;muxIndex < aShotList->getMuxSize();++muxIndex)
+    {
+        unsigned int index = 0;
+        for(unsigned int i=0;i<TOTAL_CHANNEL;++i)
+        {
+            unsigned short receiveTas = mapperArrayPointer.get()[index +  2];
+            unsigned short receiveElement = mapperArrayPointer.get()[index +  2 + aShotList->getMuxValue(muxIndex)];
+            AScanData ascan = aParser->searchAscanDataFromOneTasAscanDataOfCE(aOneTasAScanData,TasElementIndex(TasIndex(receiveTas),ElementIndex(GeometryIndex(receiveElement))));
+            aAmplificationData.get()[muxIndex*TOTAL_CHANNEL+i] = ascan.getAmplification()[0];
+            std::copy(ascan.get(), ascan.get() + aParser->getDataLength(), aAScanData.get() + (muxIndex*TOTAL_CHANNEL+i)*VARIABLE_WINDOW_ASCAN_LENGTH + START_POINT[aOneTasAScanData.getSenderTasNumber() - 1][receiveTas - 1]);
+            index+=9;
+        }
+    }
+}
+
+void MatlabCreatorVariableWindowPrivate::getAScanOfMPAndAmplification(std::shared_ptr<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData,unsigned short aGeometryElement,MotorPosition aMotorPosition)
+{
+    std::shared_ptr<unsigned short> mapperArrayPointer = MapperDataBase::getMapperArray();
+    for(unsigned int muxIndex = 0;muxIndex < aShotList->getMuxSize();++muxIndex)
+    {
+        unsigned int index = 0;
+        for(unsigned int i=0;i<TOTAL_CHANNEL;++i)
+        {
+            unsigned short receiveTas = mapperArrayPointer.get()[index +  2];
+            unsigned short receiveElement = mapperArrayPointer.get()[index +  2 + aShotList->getMuxValue(muxIndex)];
+            AScanData ascan = aParser->searchAscanDataFromOneTasAscanDataOfMP(aOneTasAScanData,ElementIndex(GeometryIndex(aGeometryElement)),TasElementIndex(TasIndex(receiveTas),ElementIndex(GeometryIndex(receiveElement))),aMotorPosition);
+            double* float16Ascan = new double[aParser->getDataLength()];
+            for(unsigned int j=0; j<aParser->getDataLength(); ++j)
+            {
+                float16Ascan[j] = convertfp16tofloat(ascan.get()[j]);
+            }
+            aAmplificationData.get()[muxIndex*TOTAL_CHANNEL+i] = ascan.getAmplification()[0];
+            double average = calcuteAverageOfAscan(float16Ascan, aParser->getDataLength());
+            std::fill_n(aAScanData.get() + (muxIndex*TOTAL_CHANNEL+i)*VARIABLE_WINDOW_ASCAN_LENGTH , VARIABLE_WINDOW_ASCAN_LENGTH, average);
+            //memset(aAScanData.get() + (muxIndex*TOTAL_CHANNEL+i)*VARIABLE_WINDOW_ASCAN_LENGTH, average, sizeof(double) * START_POINT[aOneTasAScanData.getSenderTasNumber() - 1][receiveTas - 1]);
+            std::copy(float16Ascan, float16Ascan + aParser->getDataLength(), aAScanData.get() + (muxIndex*TOTAL_CHANNEL+i)*VARIABLE_WINDOW_ASCAN_LENGTH + START_POINT[aOneTasAScanData.getSenderTasNumber() - 1][receiveTas - 1]);
+            //memset(aAScanData.get() + (muxIndex*TOTAL_CHANNEL+i)*VARIABLE_WINDOW_ASCAN_LENGTH +START_POINT[aOneTasAScanData.getSenderTasNumber() - 1][receiveTas - 1]+aParser->getDataLength(), average,  sizeof(double) * (VARIABLE_WINDOW_ASCAN_LENGTH - aParser->getDataLength() - START_POINT[aOneTasAScanData.getSenderTasNumber() - 1][receiveTas - 1]));
+            index+=9;
+            delete[] float16Ascan;
+        }
+    }
+}
+
+void MatlabCreatorVariableWindowPrivate::createCEMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath)
+{
+    DirHelper dir;
+    if(!dir.exists(aDirectoryPath))
+    {
+        return;
+    }
+    mat_t* matfp = nullptr;
+    std::string ceMatFileName = aDirectoryPath + SLASH_CHAR + "CE.mat";
+    matfp = Mat_CreateVer(ceMatFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+    if (matfp == nullptr)
+    {
+        return;
+    }
+    matvar_t* ceVar = nullptr;
+    matvar_t* ceSfVar = nullptr;
+    matvar_t* ceOffSetVar = nullptr;
+    CEData ceData = aParser->getCEData();
+    CEPointer ce = ceData.getCE();
+    size_t ceDims[2] = {ce.getLength(),1};
+    size_t ceSfDims[2] = {1,1};
+    size_t ceOffSetDims[2] = {1,1};
+    double ceSf = ceData.getCE_SF();
+    double ceOffSet = ceData.getCEOffset();
+    ceVar =  Mat_VarCreate("CE",MAT_C_DOUBLE,MAT_T_UINT16,2,ceDims,ce.get(),0);
+    ceSfVar =  Mat_VarCreate("CE_SF",MAT_C_DOUBLE,MAT_T_DOUBLE,2,ceSfDims,&ceSf,0);
+    ceOffSetVar =  Mat_VarCreate("CEOffset",MAT_C_DOUBLE,MAT_T_DOUBLE,2,ceOffSetDims,&ceOffSet,0);
+    Mat_VarWrite(matfp,ceVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,ceSfVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,ceOffSetVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(ceVar);
+    Mat_VarFree(ceSfVar);
+    Mat_VarFree(ceOffSetVar);
+    Mat_Close(matfp);
+}
+
+void MatlabCreatorVariableWindowPrivate::createInfoMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath)
+{
+    DirHelper dir;
+    if(!dir.exists(aDirectoryPath))
+    {
+        return;
+    }
+    mat_t* matfp = nullptr;
+    std::string infoMatFileName = aDirectoryPath + SLASH_CHAR + "info.mat";
+    matfp = Mat_CreateVer(infoMatFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+    if (matfp == nullptr)
+    {
+        return;
+    }
+    size_t structDims[1] ={1};
+    const char* field[7] = {"shotlist","samplenumber","SampleRate","Datatype","MeasurementID","DACDelay","FilterBypass"};
+    matvar_t* structVar = Mat_VarCreateStruct("MetaData",1,structDims,field,7);
+    //shotList
+    std::shared_ptr<ShotList> shotList = aParser->getShotList();
+    ShotListArray shotListArray = shotList->getShotListArray();
+    size_t shotListDims[2] ={shotListArray.getLength()/4,4};
+    matvar_t* shotListVar =  Mat_VarCreate("shotlist",MAT_C_DOUBLE,MAT_T_DOUBLE,2,shotListDims,shotListArray.get(),0);
+    Mat_VarSetStructFieldByName(structVar, "shotlist", 0, shotListVar);
+    //SampleNumber
+    MetaData metaData = aParser->getMetaData();
+    double smpleNumber = VARIABLE_WINDOW_ASCAN_LENGTH;
+    size_t sampleNumberDims[2] ={1,1};
+    matvar_t* sampleNumberVar =  Mat_VarCreate("samplenumber",MAT_C_DOUBLE,MAT_T_DOUBLE,2,sampleNumberDims,&smpleNumber,0);
+    Mat_VarSetStructFieldByName(structVar, "samplenumber", 0, sampleNumberVar);
+    //SampleRate
+    double sampleRate = metaData.getSamplerate();
+    size_t sampleRateDims[2] ={1,1};
+    matvar_t* sampleRateVar =  Mat_VarCreate("SampleRate",MAT_C_DOUBLE,MAT_T_DOUBLE,2,sampleRateDims,&sampleRate,0);
+    Mat_VarSetStructFieldByName(structVar, "SampleRate", 0, sampleRateVar);
+    //Datatype
+    std::string dataType = metaData.getDataType();
+    size_t dataTypeDims[2] ={1,dataType.size()};
+    matvar_t* dataTypeVar =  Mat_VarCreate("Datatype",MAT_C_CHAR,MAT_T_INT8,2,dataTypeDims,const_cast<char*>(dataType.c_str()),0);
+    Mat_VarSetStructFieldByName(structVar, "Datatype", 0, dataTypeVar);
+    //MeasurementID
+    std::string measurementID = metaData.getMeasurementID();
+    size_t measurementIDDims[2] ={1,measurementID.size()};
+    matvar_t* measurementIDVar =  Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast<char*>(measurementID.c_str()),0);
+    Mat_VarSetStructFieldByName(structVar, "MeasurementID", 0, measurementIDVar);
+    //DACDelay
+    double dacDelay = metaData.getDacDelay();
+    size_t dacDelayDims[2] ={1,1};
+    matvar_t* dacDelayVar =  Mat_VarCreate("DACDelay",MAT_C_DOUBLE,MAT_T_DOUBLE,2,dacDelayDims,&dacDelay,0);
+    Mat_VarSetStructFieldByName(structVar, "DACDelay", 0, dacDelayVar);
+    //FilterBypass
+    double filterByPass = metaData.getFilterByPass();
+    size_t filterByPassDims[2] ={1,1};
+    matvar_t* filterByPassVar =  Mat_VarCreate("FilterBypass",MAT_C_DOUBLE,MAT_T_DOUBLE,2,filterByPassDims,&filterByPass,0);
+    Mat_VarSetStructFieldByName(structVar, "FilterBypass", 0, filterByPassVar);
+    Mat_VarWrite(matfp,structVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(structVar);
+
+    //AScanDataType
+    dataTypeVar = Mat_VarCreate("AScanDatatype",MAT_C_CHAR,MAT_T_INT8,2,dataTypeDims,const_cast<char*>(dataType.c_str()),0);
+    Mat_VarWrite(matfp,dataTypeVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(dataTypeVar);
+
+    //NumberSamples
+    sampleNumberVar =  Mat_VarCreate("NumberSamples",MAT_C_DOUBLE,MAT_T_DOUBLE,2,sampleNumberDims,&smpleNumber,0);
+    Mat_VarWrite(matfp,sampleNumberVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(sampleNumberVar);
+
+    //SampleRate
+    sampleRateVar =  Mat_VarCreate("SampleRate",MAT_C_DOUBLE,MAT_T_DOUBLE,2,sampleRateDims,&sampleRate,0);
+    Mat_VarWrite(matfp,sampleRateVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(sampleRateVar);
+
+    //Hardware
+    std::string hardware = "USCT3dv3";
+    size_t hardwareDims[2] ={1,hardware.size()};
+    matvar_t* hardwareVar = Mat_VarCreate("Hardware",MAT_C_CHAR,MAT_T_INT8,2,hardwareDims,const_cast<char*>(hardware.c_str()),0);
+    Mat_VarWrite(matfp,hardwareVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(hardwareVar);
+
+    //HardwareVersion
+    std::string hardwareVersion = "3.0";
+    size_t hardwareVersionDims[2] ={1,hardwareVersion.size()};
+    matvar_t* hardwareVersionVar = Mat_VarCreate("HardwareVersion",MAT_C_CHAR,MAT_T_INT8,2,hardwareVersionDims,const_cast<char*>(hardwareVersion.c_str()),0);
+    Mat_VarWrite(matfp,hardwareVersionVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(hardwareVersionVar);
+
+    //Bandpassundersampling
+    double bandpassundersampling = 0;
+    size_t bandpassDims[2] ={1,1};
+    matvar_t* bandpassVar = Mat_VarCreate("Bandpassundersampling",MAT_C_DOUBLE,MAT_T_DOUBLE,2,bandpassDims,&bandpassundersampling,0);
+    Mat_VarWrite(matfp,bandpassVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(bandpassVar);
+
+    Mat_Close(matfp);
+}
+
+void MatlabCreatorVariableWindowPrivate::createCEMeasuredMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath)
+{
+    DirHelper dir;
+    if(!dir.exists(aDirectoryPath))
+    {
+        return;
+    }
+    mat_t* matfp = nullptr;
+    std::string ceMeasuredMatFileName = aDirectoryPath + SLASH_CHAR + "CEMeasured.mat";
+    matfp = Mat_CreateVer(ceMeasuredMatFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+    if (matfp == nullptr)
+    {
+        return;
+    }
+    MetaData metaData = aParser->getMetaData();
+
+    //MeasurementID
+    std::string measurementID = metaData.getMeasurementID();
+    size_t measurementIDDims[2] ={1,measurementID.size()};
+    matvar_t* measurementIDVar =  Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast<char*>(measurementID.c_str()),0);
+
+    //receiverIndices
+    ReceiverIndicesPointer receiverIndices = metaData.getReceiverIndices();
+    double* writeDataOfReceiverIndices = new double[receiverIndices.getLength()];
+    std::copy(receiverIndices.get(), receiverIndices.get() + receiverIndices.getLength(), writeDataOfReceiverIndices);
+    size_t receiverIndicesDims[2] ={receiverIndices.getLength(),1};
+    matvar_t* receiverIndicesVar =  Mat_VarCreate("receiverIndices",MAT_C_DOUBLE,MAT_T_DOUBLE,2,receiverIndicesDims,writeDataOfReceiverIndices,0);
+    delete[] writeDataOfReceiverIndices;
+
+    //TASIndices
+    TasIndicesPointer tasIndices = metaData.getTasIndices();
+    double* writeDataOfTasIndices = new double[tasIndices.getLength()];
+    std::copy(tasIndices.get(), tasIndices.get() + tasIndices.getLength(), writeDataOfTasIndices);
+    size_t tasIndicesDims[2] ={tasIndices.getLength(),1};
+    matvar_t* tasIndicesVar =  Mat_VarCreate("TASIndices",MAT_C_DOUBLE,MAT_T_DOUBLE,2,tasIndicesDims,writeDataOfTasIndices,0);
+    delete[] writeDataOfTasIndices;
+
+    //CEMeasured
+    CEMeasuredData cEMeasured = aParser->getAllCEMeasuredData();
+    double* ceMeasuredData;
+    size_t cEMeasuredDims[2];
+    if(cEMeasured.isNull())
+    {
+        CEPointer ce = aParser->getCEData().getCE();
+        ceMeasuredData = new double[ce.getLength() * RECEIVE_ELEMENT_COUNT];
+        for(size_t i=0; i<RECEIVE_ELEMENT_COUNT; ++i)
+        {
+            std::copy(ce.get(), ce.get()+ce.getLength(), ceMeasuredData);
+            ceMeasuredData += RECEIVE_ELEMENT_COUNT;
+        }
+        cEMeasuredDims[0] = ce.getLength();
+        cEMeasuredDims[1] = RECEIVE_ELEMENT_COUNT;
+    }
+    else
+    {
+        ceMeasuredData = new double[VARIABLE_WINDOW_ASCAN_LENGTH * RECEIVE_ELEMENT_COUNT];
+        memset(ceMeasuredData, 0, sizeof (double) * VARIABLE_WINDOW_ASCAN_LENGTH * RECEIVE_ELEMENT_COUNT);
+        for(unsigned int i=0; i<RECEIVE_ELEMENT_COUNT; ++i)
+        {
+            unsigned int tasNum = tasIndices.get()[i];
+            double* float16Ascan = new double[cEMeasured.getAscanDataLength()];
+            for(unsigned int j=0; j<cEMeasured.getAscanDataLength(); ++j)
+            {
+                float16Ascan[j] = convertfp16tofloat((cEMeasured.get() + i * cEMeasured.getAscanDataLength())[j]);
+            }
+            double average = calcuteAverageOfAscan(float16Ascan, cEMeasured.getAscanDataLength());
+            std::fill_n(ceMeasuredData + i * VARIABLE_WINDOW_ASCAN_LENGTH , VARIABLE_WINDOW_ASCAN_LENGTH, average);
+            //memset(ceMeasuredData + i * VARIABLE_WINDOW_ASCAN_LENGTH, average, sizeof(double) * START_POINT[tasNum-1][tasNum-1]);
+            std::copy(float16Ascan, float16Ascan + cEMeasured.getAscanDataLength(), ceMeasuredData + i * VARIABLE_WINDOW_ASCAN_LENGTH + START_POINT[tasNum-1][tasNum-1]);
+            //memset(ceMeasuredData + i * VARIABLE_WINDOW_ASCAN_LENGTH + START_POINT[tasNum-1][tasNum-1] + cEMeasured.getAscanDataLength(), average,  sizeof(double) * (VARIABLE_WINDOW_ASCAN_LENGTH - START_POINT[tasNum-1][tasNum-1] - cEMeasured.getAscanDataLength()));
+            delete[] float16Ascan;
+        }
+
+        //ceMeasuredData = cEMeasured.get();
+        cEMeasuredDims[0] = VARIABLE_WINDOW_ASCAN_LENGTH;
+        cEMeasuredDims[1] = RECEIVE_ELEMENT_COUNT;
+    }
+    matvar_t* cEMeasuredVar =  Mat_VarCreate("CEMeasured",MAT_C_DOUBLE,MAT_T_DOUBLE,2,cEMeasuredDims,ceMeasuredData,0);
+
+    //CEOffset
+    CEData ceData = aParser->getCEData();
+    double ceOffSet = ceData.getCEOffset();
+    size_t ceOffSetDims[2] ={1,1};
+    matvar_t* ceOffSetVar =  Mat_VarCreate("CEOffset",MAT_C_DOUBLE,MAT_T_DOUBLE,2,ceOffSetDims,&ceOffSet,0);
+
+    //CE_SF
+    double ceSF = ceData.getCE_SF();
+    size_t ceSFDims[2] ={1,1};
+    matvar_t* ceSFVar =  Mat_VarCreate("CE_SF",MAT_C_DOUBLE,MAT_T_DOUBLE,2,ceSFDims,&ceSF,0);
+
+    Mat_VarWrite(matfp,measurementIDVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,receiverIndicesVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,tasIndicesVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,cEMeasuredVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,ceOffSetVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,ceSFVar,MAT_COMPRESSION_NONE);
+
+    Mat_VarFree(measurementIDVar);
+    Mat_VarFree(receiverIndicesVar);
+    Mat_VarFree(tasIndicesVar);
+    Mat_VarFree(cEMeasuredVar);
+    Mat_VarFree(ceOffSetVar);
+    Mat_VarFree(ceSFVar);
+    Mat_Close(matfp);
+}
+
+void MatlabCreatorVariableWindowPrivate::createJumoTempMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath)
+{
+    DirHelper dir;
+    if(!dir.exists(aDirectoryPath))
+    {
+        return;
+    }
+    mat_t* matfp = nullptr;
+    std::string jumoTempMatFileName = aDirectoryPath + SLASH_CHAR + "JumoTemp.mat";
+    matfp = Mat_CreateVer(jumoTempMatFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+    if (matfp == nullptr)
+    {
+        return;
+    }
+
+    //JumoTemperature1
+    TemperatureData temperatureData = aParser->getTemperatureData();
+    JumoTemperaturePointer jumoTemperature1 = temperatureData.getJumoTemperature1();
+    unsigned long long jumoLength = jumoTemperature1.getLength();
+    double* writeData = new double[jumoLength];
+    std::copy(jumoTemperature1.get(), jumoTemperature1.get() + jumoLength, writeData);
+    size_t jumoTemperature1Dims[2] ={1,jumoTemperature1.getLength()};
+    matvar_t* jumoTemperature1Var =  Mat_VarCreate("JumoTemperature1",MAT_C_DOUBLE,MAT_T_DOUBLE,2,jumoTemperature1Dims,writeData,0);
+    delete[] writeData;
+
+    //JumoTemperature2
+    JumoTemperaturePointer jumoTemperature2 = temperatureData.getJumoTemperature2();
+    jumoLength = jumoTemperature2.getLength();
+    writeData = new double[jumoLength];
+    std::copy(jumoTemperature2.get(), jumoTemperature2.get() + jumoLength, writeData);
+    size_t jumoTemperature2Dims[2] ={1,jumoTemperature2.getLength()};
+    matvar_t* jumoTemperature2Var =  Mat_VarCreate("JumoTemperature2",MAT_C_DOUBLE,MAT_T_DOUBLE,2,jumoTemperature2Dims,writeData,0);
+    delete[] writeData;
+
+    //JumoTemperature3
+    JumoTemperaturePointer jumoTemperature3 = temperatureData.getJumoTemperature3();
+    jumoLength = jumoTemperature3.getLength();
+    writeData = new double[jumoLength];
+    std::copy(jumoTemperature3.get(), jumoTemperature3.get() + jumoLength, writeData);
+    size_t jumoTemperature3Dims[2] ={1,jumoTemperature3.getLength()};
+    matvar_t* jumoTemperature3Var =  Mat_VarCreate("JumoTemperature3",MAT_C_DOUBLE,MAT_T_DOUBLE,2,jumoTemperature3Dims,writeData,0);
+    delete[] writeData;
+
+    //JumoTemperature4
+    JumoTemperaturePointer jumoTemperature4 = temperatureData.getJumoTemperature4();
+    jumoLength = jumoTemperature4.getLength();
+    writeData = new double[jumoLength];
+    std::copy(jumoTemperature4.get(), jumoTemperature4.get() + jumoLength, writeData);
+    size_t jumoTemperature4Dims[2] ={1,jumoTemperature4.getLength()};
+    matvar_t* jumoTemperature4Var =  Mat_VarCreate("JumoTemperature4",MAT_C_DOUBLE,MAT_T_DOUBLE,2,jumoTemperature4Dims,writeData,0);
+    delete[] writeData;
+
+    //TimeStamps
+//    MetaData metaData = aParser->getMetaData();
+//    TimeStampsPointer timeStamps = metaData.getTimeStamps();
+//    size_t timeStampsDims[2] ={1,timeStamps.getLength()};
+//    matvar_t* timeStampsVar =  Mat_VarCreate("TimeStamps",MAT_C_DOUBLE,MAT_T_DOUBLE,2,timeStampsDims,timeStamps.getArray().get(),0);
+
+    //MeasurementID
+    MetaData metaData = aParser->getMetaData();
+    std::string measurementID = metaData.getMeasurementID();
+    size_t measurementIDDims[2] ={1,measurementID.size()};
+    matvar_t* measurementIDVar =  Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast<char*>(measurementID.c_str()),0);
+
+    Mat_VarWrite(matfp,jumoTemperature1Var,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,jumoTemperature2Var,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,jumoTemperature3Var,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,jumoTemperature4Var,MAT_COMPRESSION_NONE);
+//    Mat_VarWrite(matfp,timeStampsVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,measurementIDVar,MAT_COMPRESSION_NONE);
+
+    Mat_VarFree(jumoTemperature1Var);
+    Mat_VarFree(jumoTemperature2Var);
+    Mat_VarFree(jumoTemperature3Var);
+    Mat_VarFree(jumoTemperature4Var);
+//    Mat_VarFree(timeStampsVar);
+    Mat_VarFree(measurementIDVar);
+    Mat_Close(matfp);
+}
+
+void MatlabCreatorVariableWindowPrivate::createTasTempMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath)
+{
+    DirHelper dir;
+    if(!dir.exists(aDirectoryPath))
+    {
+        return;
+    }
+    mat_t* matfp = nullptr;
+    std::string tasTempMatFileName = aDirectoryPath + SLASH_CHAR + "TASTemp.mat";
+    matfp = Mat_CreateVer(tasTempMatFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+    if (matfp == nullptr)
+    {
+        return;
+    }
+    //TASTemperature
+    TemperatureData temperatureData = aParser->getTemperatureData();
+    std::vector<TasTemperaturePointer> temperature = temperatureData.getTasTemperature();
+    if(temperature.size() == 0)
+    {
+         Mat_Close(matfp);
+         return;
+    }
+    size_t tasTemperatureDims[3]{2,temperatureData.getUsedTasNum(),temperatureData.getAperaturePosition()};
+    unsigned long long temperatureLength = temperature.size() * temperature.at(0).getLength();
+    double* writeData = new double[temperatureLength];
+    double* tempData = writeData;
+    for(unsigned int i=0;i<temperature.size();++i)
+    {
+        std::copy(temperature.at(i).get(), temperature.at(i).get() + temperature.at(i).getLength(), tempData);
+        tempData+=temperature.at(i).getLength();
+    }
+    matvar_t* tasTemperatureVar =  Mat_VarCreate("TASTemperature",MAT_C_DOUBLE,MAT_T_DOUBLE,3,tasTemperatureDims,writeData,0);
+    Mat_VarWrite(matfp,tasTemperatureVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(tasTemperatureVar);
+    delete[] writeData;
+
+    //TASTemperatureRawdata
+    std::vector<std::vector<TasTemperaturePointer>> temperatureRawData = temperatureData.getTasTemperatureRawdata();
+    if(temperature.size() == 0)
+    {
+         Mat_Close(matfp);
+         return;
+    }
+    size_t tasTemperatureRawDataDims[4]{2,temperatureRawData.at(0).at(0).getLength()/2,temperatureRawData.at(0).size(),temperatureRawData.size()};
+    unsigned long long tempRawDataLength = temperatureRawData.size() * temperatureRawData.at(0).size() * temperatureRawData.at(0).at(0).getLength();
+    writeData = new double[tempRawDataLength];
+    tempData = writeData;
+     for(unsigned int i=0;i<temperatureRawData.size();++i)
+     {
+         for(unsigned int j=0;j<temperatureRawData.at(i).size();++j)
+         {
+             std::copy(temperatureRawData.at(i).at(j).get(), temperatureRawData.at(i).at(j).get() + temperatureRawData.at(i).at(j).getLength(), tempData);
+             tempData+=temperatureRawData.at(i).at(j).getLength();
+         }
+     }
+     matvar_t* tempRawDataVar =  Mat_VarCreate("TASTemperatureRawdata",MAT_C_DOUBLE,MAT_T_DOUBLE,4,tasTemperatureRawDataDims,writeData,0);
+     Mat_VarWrite(matfp,tempRawDataVar,MAT_COMPRESSION_NONE);
+     Mat_VarFree(tempRawDataVar);
+     delete[] writeData;
+     Mat_Close(matfp);
+
+}
+
+void MatlabCreatorVariableWindowPrivate::createTasTemCompMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath)
+{
+    DirHelper dir;
+    if(!dir.exists(aDirectoryPath))
+    {
+        return;
+    }
+    mat_t* matfp = nullptr;
+    std::string tasTempMatFileName = aDirectoryPath + SLASH_CHAR + "TASTempComp.mat";
+    matfp = Mat_CreateVer(tasTempMatFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+    if (matfp == nullptr)
+    {
+        return;
+    }
+    //TASTemperatureComp
+    TemperatureData temperatureData = aParser->getTemperatureData();
+    std::vector<TasTemperatureCompPointer> temperatureComp = temperatureData.getTasTemperatureComp();
+    if(temperatureComp.size() == 0)
+    {
+         Mat_Close(matfp);
+         return;
+    }
+    size_t* tasTemperatureCompDims = new size_t[3]{2,temperatureData.getUsedTasNum(),temperatureData.getAperaturePosition()};
+    unsigned long long temperatureCompLength = temperatureComp.size() * temperatureComp.at(0).getLength();
+    double* writeData = new double[temperatureCompLength];
+    double* tempData = writeData;
+    for(unsigned int i=0;i<temperatureComp.size();++i)
+    {
+        std::copy(temperatureComp.at(i).get(), temperatureComp.at(i).get() + temperatureComp.at(i).getLength(), tempData);
+        tempData+=temperatureComp.at(i).getLength();
+    }
+    matvar_t* tasTemperatureVar =  Mat_VarCreate("TASTemperature",MAT_C_DOUBLE,MAT_T_DOUBLE,3,tasTemperatureCompDims,writeData,0);
+    delete[] writeData;
+    delete[] tasTemperatureCompDims;
+    Mat_VarWrite(matfp,tasTemperatureVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(tasTemperatureVar);
+
+
+
+    //TASTemperatureRawdata
+
+    Mat_Close(matfp);
+}
+
+void MatlabCreatorVariableWindowPrivate::createMeasurementRotationMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath)
+{
+    DirHelper dir;
+    if(!dir.exists(aDirectoryPath))
+    {
+        return;
+    }
+
+    std::vector<RotationMatrixPointer> rotationMatrixs = aParser->getMovementData().getRotationMatrix();
+    for(unsigned int i=0;i<rotationMatrixs.size();++i)
+    {
+        mat_t* matfp = nullptr;
+        std::string measurementRotationFileName = std::string("measurementRotation0") + std::to_string(i+1) + std::string(".mat");
+        std::string ceMatFileName = aDirectoryPath + SLASH_CHAR + measurementRotationFileName;
+        matfp = Mat_CreateVer(ceMatFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+        if (matfp == nullptr)
+        {
+            return;
+        }
+
+        //rotationMatrix
+        RotationMatrixPointer rotationMatrix = rotationMatrixs.at(i);
+        unsigned long long rotationMatrixLength = rotationMatrix.getLength();
+        size_t rotationMatrixDims[2] ={4,4};
+        double* writeData =  new double[rotationMatrixLength];
+        std::copy(rotationMatrix.get(),rotationMatrix.get() + rotationMatrixLength,writeData);
+        matvar_t* rotationMatrixVar =  Mat_VarCreate("rotationMatrix",MAT_C_DOUBLE,MAT_T_DOUBLE,2,rotationMatrixDims,writeData,0);
+        delete[] writeData;
+
+        //MeasurementID
+        std::string measurementID = aParser->getMetaData().getMeasurementID();
+        size_t measurementIDDims[2] ={1,measurementID.size()};
+        matvar_t* measurementIDVar =  Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast<char*>(measurementID.c_str()),0);
+
+        Mat_VarWrite(matfp,rotationMatrixVar,MAT_COMPRESSION_NONE);
+        Mat_VarWrite(matfp,measurementIDVar,MAT_COMPRESSION_NONE);
+        Mat_VarFree(rotationMatrixVar);
+        Mat_VarFree(measurementIDVar);
+        Mat_Close(matfp);
+    }
+}
+
+void MatlabCreatorVariableWindowPrivate::createMovementsMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath)
+{
+    DirHelper dir;
+    if(!dir.exists(aDirectoryPath))
+    {
+        return;
+    }
+
+    mat_t* matfp = nullptr;
+    std::string movementsMatFileName = aDirectoryPath + SLASH_CHAR + "Movements.mat";
+    matfp = Mat_CreateVer(movementsMatFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+    if (matfp == nullptr)
+    {
+        return;
+    }
+
+    MetaData metaData = aParser->getMetaData();
+    //MovementsListreal
+    MovementsListRealPointer movementsListReal = aParser->getMovementData().getMovementsListReal();
+    unsigned long long movementsListRealLength = movementsListReal.getLength();
+    unsigned short aperturePositionNum = metaData.getAperturePositionNumber();
+    size_t movementsListRealDims[2] ={aperturePositionNum,2}; //2 means heigh and rotation;
+    double* writeData = new double[movementsListRealLength];
+    std::copy(movementsListReal.get(),movementsListReal.get()+movementsListRealLength,writeData);
+    matvar_t* movementsListRealVar =  Mat_VarCreate("MovementsListreal",MAT_C_DOUBLE,MAT_T_DOUBLE,2,movementsListRealDims,writeData,0);
+    delete[] writeData;
+
+    //TimeStamps
+    TimeStampsPointer timeStamps = metaData.getTimeStamps();
+    size_t timeStampsDims[2] ={1,timeStamps.getLength()};
+    matvar_t* timeStampsVar =  Mat_VarCreate("TimeStamps",MAT_C_DOUBLE,MAT_T_DOUBLE,2,timeStampsDims,timeStamps.get(),0);
+
+    //MeasurementID
+    std::string measurementID = metaData.getMeasurementID();
+    size_t measurementIDDims[2] ={1,measurementID.size()};
+    matvar_t* measurementIDVar =  Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast<char*>(measurementID.c_str()),0);
+
+    Mat_VarWrite(matfp,movementsListRealVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,timeStampsVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,measurementIDVar,MAT_COMPRESSION_NONE);
+    Mat_VarFree(movementsListRealVar);
+    Mat_VarFree(timeStampsVar);
+    Mat_VarFree(measurementIDVar);
+    Mat_Close(matfp);
+}
+
+void MatlabCreatorVariableWindowPrivate::createPatDataMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath)
+{
+    DirHelper dir;
+    if(!dir.exists(aDirectoryPath))
+    {
+        return;
+    }
+
+    mat_t* matfp = nullptr;
+    std::string movementsMatFileName = aDirectoryPath + SLASH_CHAR + "patData.mat";
+    matfp = Mat_CreateVer(movementsMatFileName.c_str(),nullptr,MAT_FT_DEFAULT);
+    if (matfp == nullptr)
+    {
+        return;
+    }
+
+    PatientData patientData = aParser->getPatientData();
+    //InstitutionAddress
+    std::string institutionAddress = patientData.getInstituationAddress();
+    size_t institutionAddressDims[2] ={1,institutionAddress.size()};
+    matvar_t* institutionAddressVar =  Mat_VarCreate("InstitutionAddress",MAT_C_CHAR,MAT_T_INT8,2,institutionAddressDims,const_cast<char*>(institutionAddress.c_str()),0);
+
+    //InstitutionName
+    std::string institutionName = patientData.getInstituationName();
+    size_t institutionNameDims[2] ={1,institutionName.size()};
+    matvar_t* institutionNameVar =  Mat_VarCreate("InstitutionName",MAT_C_CHAR,MAT_T_INT8,2,institutionNameDims,const_cast<char*>(institutionName.c_str()),0);
+
+    //IsEmptyData
+    double isEmptyData = patientData.getIsEmptyData();
+    size_t isEmptyDataDims[2] ={1,1};
+    matvar_t* isEmptyDataVar =  Mat_VarCreate("IsEmptyData",MAT_C_DOUBLE,MAT_T_DOUBLE,2,isEmptyDataDims,&isEmptyData,0);
+
+    //Laterality
+    std::string laterality = patientData.getLaterality();
+    size_t lateralityDims[2] ={1,laterality.size()};
+    matvar_t* lateralityVar =  Mat_VarCreate("Laterality",MAT_C_CHAR,MAT_T_INT8,2,lateralityDims,const_cast<char*>(laterality.c_str()),0);
+
+    //MeasurementID
+    std::string measurementID = aParser->getMetaData().getMeasurementID();
+    size_t measurementIDDims[2] ={1,measurementID.size()};
+    matvar_t* measurementIDVar =  Mat_VarCreate("MeasurementID",MAT_C_CHAR,MAT_T_INT8,2,measurementIDDims,const_cast<char*>(measurementID.c_str()),0);
+
+    //OperatorName
+    std::string operatorName = patientData.getOperatorName();
+    size_t operatorNameDims[2] ={1,operatorName.size()};
+    matvar_t* operatorNameVar =  Mat_VarCreate("OperatorName",MAT_C_CHAR,MAT_T_INT8,2,operatorNameDims,const_cast<char*>(operatorName.c_str()),0);
+
+    //PatientBirthDate
+    std::string patientBirthDate = patientData.getPatientBirthDate();
+    size_t patientBirthDateDims[2] ={1,patientBirthDate.size()};
+    matvar_t* patientBirthDateVar =  Mat_VarCreate("PatientBirthDate",MAT_C_CHAR,MAT_T_INT8,2,patientBirthDateDims,const_cast<char*>(patientBirthDate.c_str()),0);
+
+    //PatientID
+    std::string patientID = patientData.getPatientID();
+    size_t patientIDDims[2] ={1,patientID.size()};
+    matvar_t* patientIDVar =  Mat_VarCreate("PatientID",MAT_C_CHAR,MAT_T_INT8,2,patientIDDims,const_cast<char*>(patientID.c_str()),0);
+
+    //PatientName
+    std::string patientName = patientData.getPatientName();
+    size_t patientNameDims[2] ={1,patientName.size()};
+    matvar_t* patientNameVar =  Mat_VarCreate("PatientName",MAT_C_CHAR,MAT_T_INT8,2,patientNameDims,const_cast<char*>(patientName.c_str()),0);
+
+    //PatientSex
+    std::string patientSex = patientData.getPatientName();
+    size_t patientSexDims[2] ={1,patientSex.size()};
+    matvar_t* patientSexVar =  Mat_VarCreate("PatientSex",MAT_C_CHAR,MAT_T_INT8,2,patientSexDims,const_cast<char*>(patientSex.c_str()),0);
+
+    //ReferringPhysicianName
+    std::string referringPhysicianName = patientData.getReferringPhysicianName();
+    size_t referringPhysicianNameDims[2] ={1,referringPhysicianName.size()};
+    matvar_t* referringPhysicianNameVar =  Mat_VarCreate("ReferringPhysicianName",MAT_C_CHAR,MAT_T_INT8,2,referringPhysicianNameDims,const_cast<char*>(referringPhysicianName.c_str()),0);
+
+    Mat_VarWrite(matfp,institutionAddressVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,institutionNameVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,isEmptyDataVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,lateralityVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,measurementIDVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,operatorNameVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,patientBirthDateVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,patientIDVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,patientNameVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,patientSexVar,MAT_COMPRESSION_NONE);
+    Mat_VarWrite(matfp,referringPhysicianNameVar,MAT_COMPRESSION_NONE);
+
+    Mat_VarFree(institutionAddressVar);
+    Mat_VarFree(institutionNameVar);
+    Mat_VarFree(isEmptyDataVar);
+    Mat_VarFree(lateralityVar);
+    Mat_VarFree(measurementIDVar);
+    Mat_VarFree(operatorNameVar);
+    Mat_VarFree(patientBirthDateVar);
+    Mat_VarFree(patientIDVar);
+    Mat_VarFree(patientNameVar);
+    Mat_VarFree(patientSexVar);
+    Mat_VarFree(referringPhysicianNameVar);
+    Mat_Close(matfp);
+}
diff --git a/src/MatLab/MatlabCreatorVariableWindowPrivate.h b/src/MatLab/MatlabCreatorVariableWindowPrivate.h
new file mode 100644
index 0000000..b039eb1
--- /dev/null
+++ b/src/MatLab/MatlabCreatorVariableWindowPrivate.h
@@ -0,0 +1,42 @@
+#ifndef MATLABCREATORPVARIABLEWINDOWRIVATE_H
+#define MATLABCREATORPVARIABLEWINDOWRIVATE_H
+
+#include <string>
+#include <memory>
+#include <vector>
+
+class OneTasAScanData;
+class Parser;
+class ShotList;
+enum class MotorPosition:unsigned short;
+
+class MatlabCreatorVariableWindowPrivate
+{
+public:
+    MatlabCreatorVariableWindowPrivate(const std::string& aDirectoryPath);
+    void setDirectoryPath(const std::string& aDirectoryPath);
+    bool createKITMat(const std::string& aOutputPath);
+
+private:
+    void getAScanOfMPAndAmplification(std::shared_ptr<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData,unsigned short aGeometryElement,MotorPosition aMotorPosition);
+    void getAScanOfCEAndAmplification(std::shared_ptr<Parser> aParser,ShotList* aShotList,OneTasAScanData aOneTasAScanData,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData);
+    void createEmitterMat(std::shared_ptr<Parser> aParser, const std::string& aFileName,std::shared_ptr<double> aAScanData,std::shared_ptr<double> aAmplificationData);
+    void createKITMatInThread(std::shared_ptr<Parser> aParser,unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath);
+    void createCEMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
+    void createInfoMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
+    void createCEMeasuredMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
+    void createJumoTempMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
+    void createTasTempMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
+    void createTasTemCompMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
+    void createMeasurementRotationMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
+    void createMovementsMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
+    void createPatDataMat(std::shared_ptr<Parser> aParser, const std::string& aDirectoryPath);
+    void producerThreadFunction(std::shared_ptr<Parser> aParser, unsigned short aStartTasNum,unsigned short aTasCount, const std::string& aOutputPath);
+
+private:
+    std::string mDirectoryPath;
+    std::vector<std::string> mFileList;
+};
+
+
+#endif // MATLABCREATORPRIVATE_H