gDataConversionUtilities.hh

Go to the documentation of this file.

/*
This file is part of CASToR.

    CASToR is free software: you can redistribute it and/or modify it under the
    terms of the GNU General Public License as published by the Free Software
    Foundation, either version 3 of the License, or (at your option) any later
    version.

    CASToR is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    details.

    You should have received a copy of the GNU General Public License along with
    CASToR (in file GNU_GPL.TXT). If not, see <http://www.gnu.org/licenses/>.

Copyright 2017-2019 all CASToR contributors listed below:

    --> Didier BENOIT, Claude COMTAT, Marina FILIPOVIC, Thibaut MERLIN, Mael MILLARDET, Simon STUTE, Valentin VIELZEUF

This is CASToR version 3.0.
*/

#ifndef UTILS_HH
#define UTILS_HH 1

#include "gVariables.hh"
#include "gOptions.hh"
#include "iDataFilePET.hh"
#include "sOutputManager.hh"
#include "sScannerManager.hh"
#include "oInterfileIO.hh"

#ifdef CASTOR_ROOT
  #ifdef _WIN32
    #include "Windows4Root.h"
  #endif
  #include "TROOT.h"
  #include "TApplication.h"
  #include "TGClient.h"
  #include "TCanvas.h"
  #include "TSystem.h"
  #include "TTree.h"
  #include "TBranch.h"
  #include "TFile.h"
#endif

#define GATE_SYS_UNKNOWN -1

#define GATE_SYS_CYLINDRICAL 0

#define GATE_SYS_ECAT 1

#define GATE_SYS_SPECT 2

#define GATE_NB_MAX_LAYERS 4 // Max number of layer in GATE = 4


vector<string> CheckGATECommand(const string& a_key, const string& a_line);

vector<string> Split(string a_line);


void ConvertValuesTomm(vector<string>& values);


template <class T>
string toString(T a_val)
{
  stringstream ss;
  ss << a_val;
  return ss.str();
}


template <typename T>
int WriteVector(ofstream& file, const string& a_key, vector <T> a_vals);

int WriteVector(ofstream& file, const string& a_key, vector <string> a_vals);

int WriteVector(ofstream& file, const string& a_key, vector <vector<string> > a_vals);



int GetGATESystemType(const string& a_pathMac);




int GetGATEMacFiles(const string& a_pathMac, vector<string> &ap_pathToMacFiles);




int GetGATEAliasesCylindrical(vector<string>  path_mac_files,
                              string&         rsector_name,
                              string&         module_name,
                              string&         submodule_name,
                              string&         crystal_name,
                              vector<string>& layers_name ,
                              int             vb );
                              
                              
                              

int GetGATEAliasesEcat(vector<string> path_mac_files,
                       string&        block_name,
                       string&        crystal_name,
                       int            vb );
                       
                       
                       

int GetGATEAliasesSPECT(vector<string> path_mac_files,
                        string&        base_name,
                        string&        crystal_name,
                        string&        pixel_name,
                        int            vb );
                        
                        
                        
                        
uint32_t ConvertIDecat(int32_t nBlocksPerRing, 
                       int32_t nBlocksLine, 
                       int32_t nCrystalsTransaxial, 
                       int32_t nCrystalsAxial, 
                       int32_t crystalID, 
                       int32_t blockID);





uint32_t ConvertIDSPECTRoot1( int32_t  a_headID,
                              float_t  a_rotAngle,
                              float_t  a_angStep,
                              uint32_t a_nProjectionsByHead);
                              
                              
                              
uint32_t ConvertIDSPECTRoot2( uint32_t a_nbSimulatedPixels,
                              uint32_t a_nPixTrs, 
                              uint32_t a_nPixAxl, 
                              int32_t a_headID,
                              int32_t a_crystalID,
                              int32_t a_pixelID,
                              float_t a_rotAngle,
                              float_t a_headAngPitch,
                              float_t a_crystalSizeAxl,
                              float_t a_crystalSizeTrs,
                              float_t a_gPosX,
                              float_t a_gPosY,
                              float_t a_gPosZ);
                             
                             
                             
                             
uint32_t ConvertIDcylindrical(uint32_t  nRsectorsAngPos,
                              uint32_t  nRsectorsAxial, 
                              bool      a_invertDetOrder,
                              int       a_rsectorIdOrder,
                              uint32_t  nModulesTransaxial,
                              uint32_t  nModulesAxial,
                              uint32_t  nSubmodulesTransaxial,
                              uint32_t  nSubmodulesAxial,
                              uint32_t  nCrystalsTransaxial, 
                              uint32_t  nCrystalsAxial, 
                              uint8_t   nLayers,
                              uint32_t* nCrystalPerLayer, 
                       vector<uint32_t> nLayersRptTransaxial,
                       vector<uint32_t> nLayersRptAxial,
                               int32_t  layerID,
                               int32_t  crystalID, 
                               int32_t  submoduleID, 
                               int32_t  moduleID, 
                               int32_t  rsectorID);

int ComputeKindGATEEvent(uint32_t eventID1, uint32_t eventID2,
                              int comptonPhantom1, int comptonPhantom2, 
                              int rayleighPhantom1, int rayleighPhantom2);



int ReadMacECAT(string a_pathMac,
              uint32_t &nCrystalsTot,
              uint32_t &nCrystalsAxial,
              uint32_t &nCrystalsTransaxial,
              uint32_t &nBlocksLine,
              uint32_t &nBlocksPerRing,
              uint32_t &start_time_ms,
              uint32_t &duration_ms,
                   int vb);


int ReadMacSPECT( string   a_pathMac,
                  float_t  &distToDetector,
                  uint32_t &nHeads,
                  uint32_t &nPixAxl,
                  uint32_t &nPixTrs,
                  float_t  &crystalSizeAxl,
                  float_t  &crystalSizeTrs,
                  uint32_t &nProjectionsTot,
                  uint32_t &nProjectionsByHead,
                  float_t  &head1stAngle,
                  float_t  &headAngPitch,
                  float_t  &headAngStepDeg,
                  int      &headRotDirection,
                  uint32_t &start_time_ms,
                  uint32_t &duration_ms,
                       int vb);
                       
                       
                       


int ReadIntfSPECT(string      a_pathIntf,
                  float_t     &ap_distToDetector,
                  uint32_t    &ap_nHeads,
                  uint32_t    &ap_nPixAxl,
                  uint32_t    &ap_nPixTrs,
                  float_t     &ap_crystalSizeAxl,
                  float_t     &ap_crystalSizeTrs,
                  uint32_t    &ap_nProjectionsTot,
                  uint32_t    &ap_nProjectionsByHead,
                  float_t     &ap_head1stAngle,
                  float_t     &ap_headAngPitch,
                  float_t     &headAngStepDeg,
                  int         &ap_headRotDirection,
                  uint32_t    &ap_start_time_ms,
                  uint32_t    &ap_duration_ms,
                  int         vb);
                  
                  
                  
                   
int ReadMacCylindrical( string a_pathMac,
                      uint8_t  &nLayers,
                      uint32_t *nb_crystal_per_layer,
                      uint32_t &nCrystalsTot,
                      uint32_t &nCrystalsAxial,
                      uint32_t &nCrystalsTransaxial, 
              vector<uint32_t> &nLayersRptAxial,
              vector<uint32_t> &nLayersRptTransaxial,
                      uint32_t &nSubmodulesAxial, 
                      uint32_t &nSubmodulesTransaxial,
                      uint32_t &nModulesAxial, 
                      uint32_t &nModulesTransaxial,
                      uint32_t &nRsectorsAxial,
                      uint32_t &nRsectorsAngPos, 
                      bool     &invert_det_order,
                      int      &rsector_id_order,
                      uint32_t &start_time_ms, 
                      uint32_t &duration_ms,
                           int vb);



int CreateGeomWithECAT(string a_pathMac, string a_pathGeom);




int CreateGeomWithCylindrical(string a_pathMac, string a_pathGeom);




int CreateGeomWithSPECT(string a_pathMac, string a_pathGeom);

#endif