文件读写_02

//这个是每次写完一个文件
uint64_t m_iADCDataLengthPerFile;
m_iADCDataLengthPerFile = m_iCellsOfUnit * m_iMiniOfAxialBlock * m_iMiniOfTranBlock 
	* m_iMicroOfAxialMiniBlock * m_iMicroOfTranMiniBlock * ConstSipmNumPerMicro * ConstADCScaleLength;


uint16_t** m_spADCFileArray;   //这个二级指针类似二维数组，第一维是文件个数，即module个数    第二维是每个文件的数据

m_spADCFileArray = new uint16_t*[m_iModuleNum]();
for(int i= 0 ; i < m_iModuleNum;i++)
{
	uint16_t* iFileADC = new uint16_t[m_iADCDataLengthPerFile]();
	memset(iFileADC, 0, m_iADCDataLengthPerFile * sizeof(uint16_t));
	m_spADCFileArray[i] = iFileADC;
}


fstream DataSubfile[FILENUMBERV4];
for (int i = 0; i < FILENUMBERV4; i++)
{
	DataSubfile[i].open(m_vADCDataFullName[i], ios::binary | ios::out | ios::trunc);
}


SaveDataADC(DataSubfile);



void CPETADCFunctorImpl::SaveDataADC(fstream *DataFile)
{
	for(int j = 0 ; j < m_iModuleNum;j++)
	{
		uint16_t * pTemp = new uint16_t[m_iADCDataLengthPerFile];
		for (int i = 0; i < m_iADCDataLengthPerFile; i++)
		{
			pTemp[i] = (unsigned int)(((m_spADCFileArray[j][i] & 0XFF00) >> 8) + ((m_spADCFileArray[j][i] & 0X00FF) << 8));
		}
		if (!DataFile[j].write((const char*)pTemp, sizeof(uint16_t)).fail())
		{
			LOG_DEV_INFO_MI << "Save ADCData file " << j << " successfully.";
		}
		else
			LOG_DEV_ERROR_MI << "Save ADCData file " << j << " failed.";
	}
}


//------------------------------------------------------------------------------------
//将m_spCoin2DMap 的值写入m_s2dMapPath 文件中
void WriteFile()
{
     std::string m_s2dMapPath;
	 m_s2dMapPath="D:\\UIH\\appdata\\MI\\PETCalibrationRawData\\TOF\\Coin2DMap";

    std::shared_ptr<uint32_t> m_spCoin2DMap;
	m_spCoin2DMap.reset(new uint32_t[m_iFullAxialCrystalNum * m_iTransCrystalNum](), std::default_delete<uint32_t[]>());// transCryastalNum = 770
	memset(m_spCoin2DMap.get(),0,m_iFullAxialCrystalNum * m_iTransCrystalNum*sizeof(uint32_t));

	uint32_t * pCoin2dMap = m_spCoin2DMap.get();
    for(int i = 0; i < counts; i++)
		{
			if (m_spCoinDataHelper->Transform(coinData, pRawData[i]))
			{
				int64_t isPrompt = static_cast<int64_t>(coinData.MarkDelay == ICoinDataHelper::MarkDelay_Prompt);
				if(isPrompt)
				{
					uint64_t indexA=coinData.AxialIndex_CrystalA*m_iTransCrystalNum+coinData.TransverseIndex_CrystalA;
					uint64_t indexB=coinData.AxialIndex_CrystalB*m_iTransCrystalNum+coinData.TransverseIndex_CrystalB;
					if(indexA<m_iFullAxialCrystalNum*m_iTransCrystalNum && indexB<m_iFullAxialCrystalNum*m_iTransCrystalNum)
					{
						pCoin2dMap[indexA] += static_cast<uint32_t>(isPrompt);
						pCoin2dMap[indexB] += static_cast<uint32_t>(isPrompt);
					}				

				}				
			}
		}


	 FILE * fp = _fsopen(m_s2dMapPath.c_str(),"wb",_SH_DENYNO);
	 fwrite(pCoin2dMap, sizeof(uint32_t), m_iFullAxialCrystalNum * m_iTransCrystalNum, fp);
	 fclose(fp);
}

//从rawdatafile 文件中读取数据，每次读取64M的大小
//将读取的数据写入
void CMIPETSpectrumGenerate::GenerateCrystalSpectrumForP2000(std::string& lutFileFullPath,std::string& rawDataFullPath,std::string& spectrumFullPath)
{

    	        unsigned int* pEnergySpectrum = new unsigned int[512*m_iBlocksOfAxialBank*m_iCrystalsOfAxialBlock*m_iBlocksOfTranBank*m_iCrystalsOfTranBlock];	
				memset(pEnergySpectrum, 0, m_iBlocksOfAxialBank*m_iCrystalsOfAxialBlock*m_iBlocksOfTranBank*m_iCrystalsOfTranBlock*512* sizeof(unsigned int));
            	std::cout << "enter into GenerateCrystalSpectrum for P2000 !";
		        if (!exists(rawDataFullPath))
		        {
			         std::cout<<"CMIPETSpectrumGenerate::GenerateCrystalSpectrumForP2000:raw data file path is not exists!";
			         return;
		        }
		       if (!exists(lutFileFullPath))
		        {
		            std::cout<< "CMIPETSpectrumGenerate::GenerateCrystalSpectrumForP2000:lut file is not exists!";				
		    	    return;
	        	}			

				unsigned int ConstReadSize = 64*1024*1024;
				boost::scoped_array<char> cReaderBuff(new char[ConstReadSize]);
				boost::scoped_array<char> cReaderBuffNew(new char[ConstReadSize +4]);
				std::ifstream fs;
				fs.open(rawDataFullPath, ios::binary | ios::in);	
			
				try
				{
				std::shared_ptr<UIH_MI::PET::ISingleDataHelper> spSingleDataHelper(UIH_MI::PET::CDataHelperFactory::CreateSingleDataHelper(RawDataVersion_V6, Product_uMIX2000));				
					while(!fs.eof())
					{						
						fs.read((char*)cReaderBuff.get(), ConstReadSize);
						uint64_t count = (uint64_t)fs.gcount();					

						for (uint64_t i = 0; i < (count /sizeof(uint64_t)); i++)
						{
							if (spSingleDataHelper->SetValue(pData[i]))
							{
								iSingleEventEnery =  (int)spSingleDataHelper->Energy();
								if (iSingleEventEnery < 512)
								{
									iMod =  spSingleDataHelper->ModuleIndex();
									iBlkX = spSingleDataHelper->BlockInModule_Transverse();
									iBlkY = spSingleDataHelper->BlockInModule_Axial();
									iPosX = spSingleDataHelper->PositionInBlock_Transverse();
									iPosY = spSingleDataHelper->PositionInBlock_Axial();
									uint64_t tempX = iBlkX*m_iblockSize + iPosX;
									uint64_t tempY = iBlkY*m_iblockSize + iPosY;
									uint64_t location = tempX*m_iBlocksOfAxialBank*m_iblockSize+tempY;

									if (location < m_iBlocksOfTranBank*m_iblockSize*m_iBlocksOfAxialBank*m_iblockSize)
									{
										uint64_t iCurCrystalX = pLUT[location]%1000 - 1;
										uint64_t iCurCrystalY = pLUT[location]/1000 - 1;
										uint64_t spectrumIndex = (iCurCrystalX *m_iBlocksOfAxialBank*m_iCrystalsOfAxialBlock + iCurCrystalY) * 512 + iSingleEventEnery;

										if (spectrumIndex < (512*m_iBlocksOfAxialBank*m_iCrystalsOfAxialBlock*m_iBlocksOfTranBank*m_iCrystalsOfTranBlock))
										{
											pEnergySpectrum[spectrumIndex]++;
										}
										else
										{
											//LOG_DEV_ERROR_MI << "CMIPETSpectrumGenerate::CrystalX = "<< iCurCrystalX << "and CrystalY =" <<iCurCrystalY;
										}
									}
									else
									{
										//LOG_DEV_ERROR_MI << "CMIPETSpectrumGenerate::have an wrong location value!location ="<<location;
									}
								}
								else
								{
									//LOG_DEV_ERROR_MI << "CMIPETSpectrumGenerate::have an wrong iSingleEventEnery value!iSingleEventEnery ="<<iSingleEventEnery;
								}
							}
						}
					}
					fs.close();
				
					std::fstream fSpectrumFile;
					fSpectrumFile.open(spectrumFullPath, ios::binary| ios::out|ios::trunc);
					fSpectrumFile.write((char*)(pEnergySpectrum),m_iBlocksOfAxialBank*m_iCrystalsOfAxialBlock*m_iBlocksOfTranBank*m_iCrystalsOfTranBlock*512*sizeof(unsigned int));
					fSpectrumFile.close();	
				}
				catch(std::exception* e)
				{
					fs.close();
					std::cout << "CMIPETSpectrumGenerate::have an exception "<<e->what() <<std::endl;
				}                
				delete[] pLUT;
				delete[] pEnergySpectrum;   

}