FEDRA emulsion software from the OPERA Collaboration
Public Member Functions | Private Attributes | List of all members
ProcessRawData Class Reference

#include <ProcessRawData.h>

Collaboration diagram for ProcessRawData:
Collaboration graph
[legend]

Public Member Functions

bool dumpCatalogInEdbStructure ()
 
bool dumpFragmentInEdbStructure ()
 
void filterTracks (bool filterTracks)
 
const char * getCatalogName ()
 
bool getClOption ()
 
bool getFilterTracksOption ()
 
const char * getFragmentName ()
 
unsigned int getFragmentsNumberFromCatalog ()
 
const char * getRootName ()
 
void initCatalog ()
 
void initFragment ()
 
int makeTracksPlot (const char *plotFileName)
 
 ProcessRawData ()
 
bool readCatalog ()
 
bool readFragment ()
 
void setCatalogName (std::string fileName)
 
void setClOption (bool noCl)
 
void setFilterTrackOption (bool filterTracks)
 
void setFragmentName (std::string fileName)
 
void setRootName (std::string fileName)
 
 ~ProcessRawData ()
 

Private Attributes

Catalog * _catalog
 
std::string _catFileName
 
bool _clusters
 
bool _filterTracks
 
std::string _fragFileName
 
Fragment * _fragment
 
std::string _outputRootFileName
 
EdbRun * _run
 

Constructor & Destructor Documentation

◆ ProcessRawData()

ProcessRawData::ProcessRawData ( )
5{
6 _run = 0;
7 _fragment = 0;
8 _catalog = 0;
9 _clusters = false;
10 _filterTracks = false;
11}
ProcessRawData::_run
EdbRun * _run
Definition: ProcessRawData.h:33
ProcessRawData::_fragment
Fragment * _fragment
Definition: ProcessRawData.h:35
ProcessRawData::_clusters
bool _clusters
Definition: ProcessRawData.h:39
ProcessRawData::_catalog
Catalog * _catalog
Definition: ProcessRawData.h:34
ProcessRawData::_filterTracks
bool _filterTracks
Definition: ProcessRawData.h:40

◆ ~ProcessRawData()

ProcessRawData::~ProcessRawData ( )
14{
15 if (_run) { _run->Close(); delete _run; _run=0; }
16 if (_fragment) { delete _fragment; _fragment=0; }
17 if (_catalog) { delete _catalog; _catalog = 0; }
18}
EdbRun::Close
void Close()
Definition: EdbRun.cxx:439

Member Function Documentation

◆ dumpCatalogInEdbStructure()

bool ProcessRawData::dumpCatalogInEdbStructure ( )
743{
744 if(!_run) _run = new EdbRun(_outputRootFileName.c_str(), "RECREATE" );
745
746// _run->GetTree()->SetMaxTreeSize(static_cast<long long>(10e9));
747 EdbRunHeader *Header = _run->GetHeader();
748 Header->SetFlag(0,2);
749 Header->SetFlag(1,1);
750 Header->SetFlag(2,1);
751 Header->SetLimits(static_cast<float>(_catalog->getXmin()),
752 static_cast<float>(_catalog->getXmax()),
753 static_cast<float>(_catalog->getYmin()),
754 static_cast<float>(_catalog->getYmax()));
755 //int index = _catalog->findConfig("Vertigo");
756 std::string retValue = _catalog->getConfigValue(_catalog->findConfig("Vertigo"),"VLayers");
757
758
759 Header->SetArea(static_cast<int>(_catalog->getXviews()*_catalog->getYviews()),
760 static_cast<float>(_catalog->getXstep()),static_cast<float>(_catalog->getYstep())
761 , atoi(retValue.c_str()),atoi(retValue.c_str()), 0);
762
763 Header->SetCCD(atoi(_catalog->getConfigValue(_catalog->findConfig("Objective"),"Width").c_str()),
764 atoi(_catalog->getConfigValue(_catalog->findConfig("Objective"),"Height").c_str()),
765 -999, // physical pixel size in microns along X
766 -999, // physical pixel size in microns along Y
767 "", // es. "Dalsa CAD4"
768 ""); // es. "Bologna"
769 Header->SetObjective(-999, // magnification
770 static_cast<float>(atof(_catalog->getConfigValue(_catalog->findConfig("Objective"),"Width").c_str())*
771 fabs(atof(_catalog->getConfigValue(_catalog->findConfig("Objective"),"PixelToMicronX").c_str()))),
772 0,0,
773 static_cast<float>(atof(_catalog->getConfigValue(_catalog->findConfig("Objective"),"Height").c_str())*
774 fabs(atof(_catalog->getConfigValue(_catalog->findConfig("Objective"),"PixelToMicronY").c_str()))),
775 0,0,
776 "", // es. "Nikon CFI - oil"
777 ""); // es, "50x"
778 float vStepTop = static_cast<float>(atof(_catalog->getConfigValue(_catalog->findConfig("Vertigo"),"TopStep").c_str()));
779 float vStepBottom = static_cast<float>(atof(_catalog->getConfigValue(_catalog->findConfig("Vertigo"),"BottomStep").c_str()));
780 float shr = static_cast<float>(atof(_catalog->getConfigValue(_catalog->findConfig("Vertigo"),"Shrinkage").c_str()));
781 float base = static_cast<float>(atof(_catalog->getConfigValue(_catalog->findConfig("Vertigo"),"BaseThickness").c_str()));
782 Header->SetPlate(-999, // plate ID
783 vStepTop*shr,
784 base,
785 vStepBottom*shr,shr,shr,
786 "", // es. "Test Plate"
787 "");
788 // Store the catalog file as TObjString
789 TObjString objstr ;
790 int i, ch;
791 FILE *stream;
792 if( (stream = fopen( _catFileName.c_str(), "rb" )) == NULL ) return false;
793 ch = fgetc( stream );
794 for( i=0; feof( stream ) == 0 ; i++ )
795 {
796 objstr.String().Append( ch );
797 ch = fgetc( stream );
798 }
799 fclose( stream );
800 objstr.Write("catalog");
801 _run->Save() ;
802 //_run->Close();
803 return true;
804}
fabs
Expr< UnaryOp< Fabs< T >, Expr< A, T, D >, T >, T, D > fabs(const Expr< A, T, D > &rhs)
Definition: UnaryOperators.hh:96
Catalog::getXstep
double getXstep()
Definition: Catalog.h:45
Catalog::getYmin
double getYmin()
Definition: Catalog.h:43
Catalog::getXmax
double getXmax()
Definition: Catalog.h:42
Catalog::getXmin
double getXmin()
Definition: Catalog.h:41
Catalog::getYmax
double getYmax()
Definition: Catalog.h:44
Catalog::getYstep
double getYstep()
Definition: Catalog.h:46
Catalog::getYviews
unsigned int getYviews()
Definition: Catalog.h:40
Catalog::getXviews
unsigned int getXviews()
Definition: Catalog.h:39
Catalog::getConfigValue
std::string getConfigValue(int index, std::string configName)
Definition: Catalog.cpp:67
Catalog::findConfig
int findConfig(std::string configName)
Definition: Catalog.cpp:21
EdbRunHeader
Definition: EdbRunHeader.h:95
EdbRun
Definition: EdbRun.h:75
EdbRun::Save
void Save()
Definition: EdbRun.cxx:424
EdbRun::GetHeader
EdbRunHeader * GetHeader() const
Definition: EdbRun.h:138
ProcessRawData::_catFileName
std::string _catFileName
Definition: ProcessRawData.h:36
ProcessRawData::_outputRootFileName
std::string _outputRootFileName
Definition: ProcessRawData.h:38
fclose
fclose(pFile)
Header
Definition: tlg2couples.C:65
NULL
#define NULL
Definition: nidaqmx.h:84

◆ dumpFragmentInEdbStructure()

bool ProcessRawData::dumpFragmentInEdbStructure ( )
808{
809 if(!_run) {
810 if ( gSystem->AccessPathName( _outputRootFileName.c_str() ) )
811 _run = new EdbRun( _outputRootFileName.c_str(), "RECREATE" );
812 else
813 _run = new EdbRun( _outputRootFileName.c_str(), "UPDATE" );
814 }
815 //run->GetTree()->SetMaxTreeSize(static_cast<long long>(10e9));
816
817 EdbView* edbView = _run->GetView();
818 //EdbSegment* edbSegment = new EdbSegment(0,0,0,0,0,0,0,0);
819 std::auto_ptr<EdbSegment> edbSegment( new EdbSegment(0,0,0,0,0,0,0,0) );
820
821 int v, t, p; // v=view, s=side, t=track, p=point
822 int tracks; // number of tracks in the fragment
823 int fclusters; // number of clusters in the fragment
824 int vclusters; // number of clusters in the view
825 float dz ; // z-length of the track segment
826 int tr_clusters; // number of cluster of the track
827 int puls ; // ePuls = (number of clusters ) OR (sum of clust areas)*1000 + (number of clusters)
828 float volume = 0;
829 int frameId = 0;
830 tracks = 0;
831 fclusters = 0;
832 _run->GetHeader()->SetNareas(_run->GetHeader()->GetNareas()+1);
833 for (v = 0; v < _fragment->getViews(); v++) //TOP
834 {
835 View *rwdView = _fragment->getView(v);
836 Side *topSide = rwdView->getTopSide();
837 vclusters = 0;
838 tracks+=topSide->getTracks();
839 edbView->Clear();
840 EdbViewHeader* edbViewHeader = edbView->GetHeader();
841 edbViewHeader->SetAffine(static_cast<float>(topSide->getMXX()),
842 static_cast<float>(topSide->getMXY()),static_cast<float>(topSide->getMYX()),
843 static_cast<float>(topSide->getMYY()),static_cast<float>(topSide->getMappedFovPosX()),
844 static_cast<float>(topSide->getMappedFovPosY()));
845
846 edbViewHeader->SetAreaID(_fragment->getIndex());
847 edbViewHeader->SetCoordXY(static_cast<float>(topSide->getStageFovPosX()), static_cast<float>(topSide->getStageFovPosY()));
848 edbViewHeader->SetCoordZ(static_cast<float>(topSide->getTopZ()),static_cast<float>(topSide->getBottomZ()),
849 static_cast<float>(rwdView->getBottomSide()->getTopZ()),static_cast<float>(rwdView->getBottomSide()->getBottomZ())); // NON capito i relevant Z
850
851 edbViewHeader->SetNframes(topSide->getLayers(),0);
852 edbViewHeader->SetNsegments(topSide->getTracks());
853 edbViewHeader->SetViewID(rwdView->getId());
854 edbViewHeader->SetColRow(rwdView->getTileX() ,rwdView->getTileY() );
855 int nframes = topSide->getLayers();
856 for( int nlvl=0; nlvl<nframes; nlvl++ )
857 {
858 edbView->AddFrame(nlvl,static_cast<float>(topSide->getLayerAt(nlvl)->zLayer),
859 topSide->getLayerAt(nlvl)->grains);
860 }
861 for (t = 0; t < topSide->getTracks(); t++) {
862 Track *tr = topSide->getTrackAt(t);
863 tr_clusters = tr->getCount();
864 puls = tr->getCount(); // dovrei mettere l'if per le opzioni di rwc2edb
865 if (tr->getGrains().size()!=0)
866 dz = static_cast<float>(tr->getGrains().at(0).z - tr->getGrains().at(tr_clusters-1).z);
867 else dz = 0.;
868
869 edbSegment->Set( static_cast<float>(tr->getX()),static_cast<float>(tr->getY()),
870 static_cast<float>(tr->getZ()),static_cast<float>(tr->getSX()),static_cast<float>(tr->getSY()),
871 dz, 0 , puls, t);
872 edbSegment->SetSigma(static_cast<float>(tr->getSigma()),-999.);
873 if (tr->getGrains().size()!=0 ) { // fixare opzioni nocl
874 volume = 0;
875 frameId = 0;
876 }
877 if (_clusters)
878 {
879 for ( p=0; p<tr_clusters;p++) {
880 for(int nlvl=frameId;nlvl<nframes;nlvl++) {
881 if(tr->getGrains().at(p).z == rwdView->getTopSide()->getLayerAt(nlvl)->zLayer) {
882 frameId=nlvl;
883 break;
884 }
885 }
886
887 edbView->AddCluster( static_cast<float>(tr->getGrains().at(p).x),
888 static_cast<float>(tr->getGrains().at(p).y),
889 static_cast<float>(tr->getGrains().at(p).z),
890 static_cast<float>(tr->getGrains().at(p).area),
891 volume,
892 frameId,
893 0,t);
894
895 }
896 }
897 edbViewHeader->SetNclusters(vclusters);
898 edbView->AddSegment(edbSegment.get()) ;
899 vclusters += tr_clusters;
900 } // end of tracks (t)
901 _run->AddView(edbView);
902 fclusters += vclusters;
903 } //end of views (v)
904
905
906
907
908 for (v = 0; v < _fragment->getViews(); v++) //BOTTOM
909 {
910 View *rwdView = _fragment->getView(v);
911 Side *bottomSide = rwdView->getBottomSide();
912 vclusters = 0;
913 tracks+=bottomSide->getTracks();
914 edbView->Clear();
915 EdbViewHeader* edbViewHeader = edbView->GetHeader();
916 edbViewHeader->SetAffine(static_cast<float>(bottomSide->getMXX()),static_cast<float>(bottomSide->getMXY()),
917 static_cast<float>(bottomSide->getMYX()),static_cast<float>(bottomSide->getMYY()),
918 static_cast<float>(bottomSide->getMappedFovPosX()),static_cast<float>(bottomSide->getMappedFovPosY()));
919 //edbViewHeader->SetAreaID(run->GetHeader()->GetNareas());
920 edbViewHeader->SetAreaID(_fragment->getIndex());
921 edbViewHeader->SetCoordXY(static_cast<float>(bottomSide->getStageFovPosX()), static_cast<float>(bottomSide->getStageFovPosY()));
922 edbViewHeader->SetCoordZ(static_cast<float>(rwdView->getTopSide()->getTopZ()),static_cast<float>(rwdView->getTopSide()->getBottomZ()),
923 static_cast<float>(rwdView->getBottomSide()->getTopZ()),static_cast<float>(rwdView->getBottomSide()->getBottomZ())); // NON capito i relevant Z
924 //edbViewHeader->SetNframes(bottomSide->getLayers(),0);
925 edbViewHeader->SetNframes(0,bottomSide->getLayers());
926 edbViewHeader->SetNsegments(bottomSide->getTracks());
927 edbViewHeader->SetViewID(rwdView->getId());
928 edbViewHeader->SetColRow(rwdView->getTileX() ,rwdView->getTileY() );
929 int nframes = bottomSide->getLayers();
930 for( int nlvl=0; nlvl<nframes; nlvl++ )
931 {
932 edbView->AddFrame(nlvl,static_cast<float>(bottomSide->getLayerAt(nlvl)->zLayer),
933 bottomSide->getLayerAt(nlvl)->grains);
934 }
935 for (t = 0; t < bottomSide->getTracks(); t++) {
936 Track *tr = bottomSide->getTrackAt(t);
937 tr_clusters = tr->getCount();
938 puls = tr->getCount(); // dovrei mettere l'if per le opzioni di rwc2edb
939 if (tr->getGrains().size()!=0)
940 dz = static_cast<float>(tr->getGrains().at(0).z - tr->getGrains().at(tr_clusters-1).z);
941 else dz = 0;
942
943 edbSegment->Set( static_cast<float>(tr->getX()),static_cast<float>(tr->getY()),
944 static_cast<float>(tr->getZ()),static_cast<float>(tr->getSX()),
945 static_cast<float>(tr->getSY()), dz, 1 , puls, t);
946 edbSegment->SetSigma(static_cast<float>(tr->getSigma()),-999.);
947 if (tr->getGrains().size()!=0 ) { // fixare opzioni nocl
948 volume = 0;
949 frameId = 0;
950 }
951 if (_clusters)
952 {
953 for ( p=0; p<tr_clusters;p++) {
954 for(int nlvl=frameId;nlvl<nframes;nlvl++) {
955 if(tr->getGrains().at(p).z == rwdView->getTopSide()->getLayerAt(nlvl)->zLayer) {
956 frameId=nlvl;
957 break;
958 }
959 }
960 edbView->AddCluster( static_cast<float>(tr->getGrains().at(p).x),
961 static_cast<float>(tr->getGrains().at(p).y),
962 static_cast<float>(tr->getGrains().at(p).z),
963 static_cast<float>(tr->getGrains().at(p).area),
964 volume,
965 frameId,
966 1,t);
967 }
968 }
969 edbViewHeader->SetNclusters(vclusters);
970 edbView->AddSegment(edbSegment.get()) ;
971 vclusters += tr_clusters;
972 } // end of tracks (t)
973 _run->AddView(edbView);
974 fclusters += vclusters;
975 } //end of views (v)
976
977// _run->Close();
978 std::cout<< "Fragment: " << _fragment->getIndex() << "\tmicrotracks: " << tracks << "\tclusters: " << fclusters << std::endl;
979 return true;
980}
dz
brick dz
Definition: RecDispMC.C:107
tr
TTree * tr
Definition: Shower_E_FromShowerRoot.C:5
EdbRunHeader::SetNareas
void SetNareas(int n)
Definition: EdbRunHeader.h:134
EdbRunHeader::GetNareas
Int_t GetNareas() const
Definition: EdbRunHeader.h:148
EdbRun::GetView
EdbView * GetView() const
Definition: EdbRun.h:110
EdbRun::AddView
void AddView()
Definition: EdbRun.cxx:305
EdbSegment
segment of the track
Definition: EdbSegment.h:63
EdbViewHeader
view identification
Definition: EdbView.h:26
EdbViewHeader::SetColRow
void SetColRow(int col, int row)
Definition: EdbView.h:105
EdbViewHeader::SetCoordZ
void SetCoordZ(float z1, float z2, float z3, float z4)
Definition: EdbView.h:102
EdbViewHeader::SetNsegments
void SetNsegments(int nseg)
Definition: EdbView.h:86
EdbViewHeader::SetAreaID
void SetAreaID(int id)
Definition: EdbView.h:100
EdbViewHeader::SetViewID
void SetViewID(int id)
Definition: EdbView.h:99
EdbViewHeader::SetNclusters
void SetNclusters(int nclu)
Definition: EdbView.h:85
EdbViewHeader::SetNframes
void SetNframes(int top, int bot)
Definition: EdbView.h:104
EdbViewHeader::SetAffine
void SetAffine(float a11, float a12, float a21, float a22, float b1, float b2)
Definition: EdbView.h:67
EdbViewHeader::SetCoordXY
void SetCoordXY(float x, float y)
Definition: EdbView.h:101
EdbView
Base scanning data object: entry into Run tree.
Definition: EdbView.h:134
EdbView::GetHeader
EdbViewHeader * GetHeader() const
Definition: EdbView.h:163
EdbView::AddSegment
EdbSegment * AddSegment(float x, float y, float z, float tx, float ty, float dz=0, int side=0, int puls=0, int id=-1)
Definition: EdbView.h:231
EdbView::AddCluster
EdbCluster * AddCluster(EdbCluster *c)
Definition: EdbView.h:225
EdbView::AddFrame
void AddFrame(int id, float z, int ncl=0, int npix=0)
Definition: EdbView.cxx:268
EdbView::Clear
void Clear()
Definition: EdbView.cxx:79
Fragment::getIndex
unsigned int getIndex()
Definition: Fragment.h:32
Fragment::getView
View * getView(int index)
Definition: Fragment.h:35
Fragment::getViews
int getViews()
Definition: Fragment.h:34
Side
Definition: Side.h:11
Side::getTopZ
double getTopZ() const
Definition: Side.h:59
Side::getLayers
int getLayers() const
Definition: Side.h:66
Side::getBottomZ
double getBottomZ() const
Definition: Side.h:60
Side::getMXX
double getMXX() const
Definition: Side.h:67
Side::getMappedFovPosX
double getMappedFovPosX() const
Definition: Side.h:64
Side::getTrackAt
Track * getTrackAt(int id)
Definition: Side.h:76
Side::getStageFovPosY
double getStageFovPosY() const
Definition: Side.h:63
Side::getMYX
double getMYX() const
Definition: Side.h:69
Side::getTracks
int getTracks() const
Definition: Side.h:80
Side::getMXY
double getMXY() const
Definition: Side.h:68
Side::getMappedFovPosY
double getMappedFovPosY() const
Definition: Side.h:65
Side::getLayerAt
Layer * getLayerAt(int id)
Definition: Side.h:75
Side::getStageFovPosX
double getStageFovPosX() const
Definition: Side.h:62
Side::getMYY
double getMYY() const
Definition: Side.h:70
Track
Definition: Track.h:10
View::getBottomSide
Side getBottomSide() const
Definition: View.h:28
View::getTileX
int getTileX() const
Definition: View.h:29
View::getId
int getId() const
Definition: View.h:31
View::getTileY
int getTileY() const
Definition: View.h:30
View::getTopSide
Side getTopSide() const
Definition: View.h:27
t
TTree * t
Definition: check_shower.C:4
tracks
TTree * tracks
Definition: check_tr.C:19
View
Definition: tlg2couples.C:89
Layer::grains
unsigned int grains
Definition: Struct.h:28
Layer::zLayer
double zLayer
Definition: Struct.h:29
p
p
Definition: testBGReduction_AllMethods.C:8

◆ filterTracks()

void ProcessRawData::filterTracks ( bool  filterTracks)
inline
53{_filterTracks = filterTracks;}
ProcessRawData::filterTracks
void filterTracks(bool filterTracks)
Definition: ProcessRawData.h:53

◆ getCatalogName()

const char * ProcessRawData::getCatalogName ( )
inline
54{return _catFileName.c_str();}

◆ getClOption()

bool ProcessRawData::getClOption ( )
inline
57{return _clusters;}

◆ getFilterTracksOption()

bool ProcessRawData::getFilterTracksOption ( )
inline
58{return _filterTracks;}

◆ getFragmentName()

const char * ProcessRawData::getFragmentName ( )
inline
55{return _fragFileName.c_str();}
ProcessRawData::_fragFileName
std::string _fragFileName
Definition: ProcessRawData.h:37

◆ getFragmentsNumberFromCatalog()

unsigned int ProcessRawData::getFragmentsNumberFromCatalog ( )
33{
34 if (_catalog)
35 return _catalog->getNfragments();
36 return 0;
37}
Catalog::getNfragments
unsigned int getNfragments()
Definition: Catalog.h:47

◆ getRootName()

const char * ProcessRawData::getRootName ( )
inline
56{return _outputRootFileName.c_str();}

◆ initCatalog()

void ProcessRawData::initCatalog ( )
21{
22 if (_catalog)
23 delete _catalog;
24 _catalog = new Catalog();
25}
Catalog
Definition: Catalog.h:7

◆ initFragment()

void ProcessRawData::initFragment ( )
27{
28 if (_fragment)
29 delete _fragment;
30 _fragment = new Fragment();
31}
TrackIndexEntry::Fragment
Int_t Fragment
Definition: tlg2couples.C:134

◆ makeTracksPlot()

int ProcessRawData::makeTracksPlot ( const char *  plotFileName)
984{
985 int nViews = _fragment->getViews();
986 int counter = 0;
987 for (int i = 0; i < nViews; i++)
988 {
989 counter += _fragment->getView(i)->getTopSide()->getTracks();
990 counter += _fragment->getView(i)->getBottomSide()->getTracks();
991 }
992 if (counter == 0)
993 return 0;
994
995 double x0,y0,z0,tx,ty,dz,sigma; // segments parameters
996 unsigned int side,puls,id; // segments parameters
997 unsigned int areasum; // segments parameters
998 double meanDeltaTheta3D; // mean 3D angular variation (computed between adiacent clusters)
999 double sigmaDeltaTheta3D; // sigma 3D angular variation (computed between adiacent clusters)
1000 double meanDeltaThetaXZ; // mean 2D angular variation - plane XZ
1001 double sigmaDeltaThetaXZ; // sigma 2D angular variation - plane XZ
1002 double meanDeltaThetaYZ; // mean 2D angular variation - plane YZ
1003 double sigmaDeltaThetaYZ; // sigma 2D angular variation - plane YZ
1004 double meanDistanceClustersTo3DLine; // mean Distance beetween cluster and 3D line fit
1005 double meanGapClusterToCluster; // mean gap beetween adiacent clusters
1006 double mx, mxSigma, qx, qxSigma, rx, xCov, xChi2; // 2D fit parameters for XZ plane
1007 double my, mySigma, qy, qySigma, ry, yCov, yChi2; // 2D fit parameters for YZ plane
1008
1009 TTree *tree = 0;
1010 TFile *outf = 0;
1011
1012 if(gSystem->AccessPathName(plotFileName))
1013 {
1014
1015 outf = new TFile(plotFileName,"UPDATE"); // update an existing file (to super-impose all fragments in the same file)
1016 tree = new TTree("plots","plots");
1017
1018 tree->Branch("x0",&x0,"x0/D");
1019 tree->Branch("y0",&y0,"y0/D");
1020 tree->Branch("z0",&z0,"z0/D");
1021 tree->Branch("tx",&tx,"tx/D");
1022 tree->Branch("ty",&ty,"ty/D");
1023 tree->Branch("dz",&dz,"dz/D");
1024 tree->Branch("side",&side,"side/i");
1025 tree->Branch("puls",&puls,"puls/i");
1026 tree->Branch("id",&id,"id/i");
1027 tree->Branch("areasum",&areasum,"areasum/i");
1028 tree->Branch("sigma",&sigma,"sigma/D");
1029 tree->Branch("meanDeltaTheta3D",&meanDeltaTheta3D,"meanDeltaTheta3D/D");
1030 tree->Branch("sigmaDeltaTheta3D",&sigmaDeltaTheta3D,"sigmaDeltaTheta3D/D");
1031 tree->Branch("meanDeltaThetaXZ",&meanDeltaThetaXZ,"meanDeltaThetaXZ/D");
1032 tree->Branch("sigmaDeltaThetaXZ",&sigmaDeltaThetaXZ,"sigmaDeltaThetaXZ/D");
1033 tree->Branch("meanDeltaThetaYZ",&meanDeltaThetaYZ,"meanDeltaThetaYZ/D");
1034 tree->Branch("sigmaDeltaThetaYZ",&sigmaDeltaThetaYZ,"sigmaDeltaThetaYZ/D");
1035 tree->Branch("meanDistanceClustersTo3DLine",&meanDistanceClustersTo3DLine,"meanDistanceClustersTo3DLine/D");
1036 tree->Branch("meanGapClusterToCluster",&meanGapClusterToCluster,"meanGapClusterToCluster/D");
1037 tree->Branch("mx",&mx,"mx/D");
1038 tree->Branch("mxSigma",&mxSigma,"mxSigma/D");
1039 tree->Branch("qx",&qx,"qx/D");
1040 tree->Branch("qxSigma",&qxSigma,"qxSigma/D");
1041 tree->Branch("xCov",&xCov,"xCov/D");
1042 tree->Branch("xChi2",&xChi2,"xChi2/D");
1043 tree->Branch("rx",&rx,"rx/D");
1044 tree->Branch("my",&my,"my/D");
1045 tree->Branch("qy",&qy,"qy/D");
1046 tree->Branch("mySigma",&mySigma,"mySigma/D");
1047 tree->Branch("qySigma",&qySigma,"qySigma/D");
1048 tree->Branch("yCov",&yCov,"yCov/D");
1049 tree->Branch("yChi2",&yChi2,"yChi2/D");
1050 tree->Branch("ry",&ry,"ry/D");
1051
1052 }
1053 else
1054 {
1055 outf = new TFile(plotFileName,"UPDATE");
1056 tree = (TTree*)(outf->Get("plots"));
1057 tree->SetBranchAddress("x0",&x0);
1058 tree->SetBranchAddress("y0",&y0);
1059 tree->SetBranchAddress("z0",&z0);
1060 tree->SetBranchAddress("tx",&tx);
1061 tree->SetBranchAddress("ty",&ty);
1062 tree->SetBranchAddress("dz",&dz);
1063 tree->SetBranchAddress("side",&side);
1064 tree->SetBranchAddress("puls",&puls);
1065 tree->SetBranchAddress("id",&id);
1066 tree->SetBranchAddress("areasum",&areasum);
1067 tree->SetBranchAddress("sigma",&sigma);
1068 tree->SetBranchAddress("meanDeltaTheta3D",&meanDeltaTheta3D);
1069 tree->SetBranchAddress("sigmaDeltaTheta3D",&sigmaDeltaTheta3D);
1070 tree->SetBranchAddress("meanDeltaThetaXZ",&meanDeltaThetaXZ);
1071 tree->SetBranchAddress("sigmaDeltaThetaXZ",&sigmaDeltaThetaXZ);
1072 tree->SetBranchAddress("meanDeltaThetaYZ",&meanDeltaThetaYZ);
1073 tree->SetBranchAddress("sigmaDeltaThetaYZ",&sigmaDeltaThetaYZ);
1074 tree->SetBranchAddress("meanDistanceClustersTo3DLine",&meanDistanceClustersTo3DLine);
1075 tree->SetBranchAddress("meanGapClusterToCluster",&meanGapClusterToCluster);
1076 tree->SetBranchAddress("mx",&mx);
1077 tree->SetBranchAddress("qx",&qx);
1078 tree->SetBranchAddress("xChi2",&xChi2);
1079 tree->SetBranchAddress("rx",&rx);
1080 tree->SetBranchAddress("my",&my);
1081 tree->SetBranchAddress("qy",&qy);
1082 tree->SetBranchAddress("yChi2",&yChi2);
1083 tree->SetBranchAddress("ry",&ry);
1084 }
1085
1086
1087 std::cout << "Saving plots into the file " << plotFileName << ": " << std::setw(2) << std::setprecision(2) << 0 << "%" << std::flush;;
1088 std::cout << "\b\b\b";
1089
1090
1091 for (int i = 0; i < nViews; i++)
1092 {
1093 View *view = _fragment->getView(i);
1094 Side *top = view->getTopSide();
1095 Side *bottom = view->getBottomSide();
1096 int nTracksTop = top->getTracks();
1097 int nTracksBottom = bottom->getTracks();
1098
1099 for (int t = 0; t < nTracksTop; t++)
1100 {
1101 Track *tr = top->getTrackAt(t);
1102 x0 = tr->getX();
1103 y0 = tr->getY();
1104 z0 = tr->getZ();
1105 tx = tr->getSX();
1106 ty = tr->getSY();
1107 sigma = tr->getSigma();
1108 dz = tr->dz;
1109 side = 1;
1110 puls = tr->getCount();
1111 id = t;
1112 areasum = tr->getAreaSum();
1113 meanDeltaTheta3D = tr->meanDeltaTheta3D;
1114 sigmaDeltaTheta3D = tr->sigmaDeltaTheta3D;
1115 meanDeltaThetaXZ = tr->meanDeltaThetaXZ;
1116 sigmaDeltaThetaXZ = tr->sigmaDeltaThetaXZ;
1117 meanDeltaThetaYZ = tr->meanDeltaThetaYZ;
1118 sigmaDeltaThetaYZ = tr->sigmaDeltaThetaYZ;
1119 meanDistanceClustersTo3DLine = tr->meanDistanceClustersTo3DLine;
1120 meanGapClusterToCluster = tr->meanGapClusterToCluster;
1121 mx = tr->mx;
1122 qx = tr->qx;
1123 rx = tr->rx;
1124 xChi2 = tr->xChi2;
1125 my = tr->my;
1126 qy = tr->qy;
1127 ry = tr->ry;
1128 yChi2 = tr->yChi2;
1129 tree->Fill();
1130 counter++;
1131 }
1132
1133 for (int b = 0; b < nTracksBottom; b++)
1134 {
1135 Track *tr = bottom->getTrackAt(b);
1136 x0 = tr->getX();
1137 y0 = tr->getY();
1138 z0 = tr->getZ();
1139 tx = tr->getSX();
1140 ty = tr->getSY();
1141 sigma = tr->getSigma();
1142 dz = tr->dz;
1143 side = 2;
1144 puls = tr->getCount();
1145 id = b;
1146 areasum = tr->getAreaSum();
1147 meanDeltaTheta3D = tr->meanDeltaTheta3D;
1148 sigmaDeltaTheta3D = tr->sigmaDeltaTheta3D;
1149 meanDeltaThetaXZ = tr->meanDeltaThetaXZ;
1150 sigmaDeltaThetaXZ = tr->sigmaDeltaThetaXZ;
1151 meanDeltaThetaYZ = tr->meanDeltaThetaYZ;
1152 sigmaDeltaThetaYZ = tr->sigmaDeltaThetaYZ;
1153 meanDistanceClustersTo3DLine = tr->meanDistanceClustersTo3DLine;
1154 meanGapClusterToCluster = tr->meanGapClusterToCluster;
1155 mx = tr->mx;
1156 qx = tr->qx;
1157 rx = tr->rx;
1158 xChi2 = tr->xChi2;
1159 my = tr->my;
1160 qy = tr->qy;
1161 ry = tr->ry;
1162 yChi2 = tr->yChi2;
1163 tree->Fill();
1164 counter++;
1165
1166 }
1167 std::cout << std::setw(2) << std::setprecision(2) << int((double) i/(nViews-1)*100) << "%" << std::flush;
1168 std::cout << "\b\b\b";
1169 }
1170 std::cout << std::endl;
1171
1172 //outf->Write();
1173 //tree->Write();
1174 tree->Write("", TObject::kOverwrite);
1175 outf->Close();
1176 return counter;
1177
1178}
z0
brick z0
Definition: RecDispMC.C:106
MIPBaseTrack::id
UInt_t id
Definition: tlg2couples.C:117

◆ readCatalog()

bool ProcessRawData::readCatalog ( )
39{
40 std::ifstream infile(_catFileName.c_str(),std::ios::binary);
41
42 if (infile.fail())
43 {
44 std::cout << "Failed to open file" << std::endl;
45 return false;
46 }
47 initCatalog();
48
49 char byteInfo;
50 infile.read((char*)&byteInfo,SIZE_OF_CHAR);
51 unsigned short headerFormat;
52 infile.read((char*)&headerFormat,SIZE_OF_UNSIGNED_SHORT_INT);
53 //if (something) format not supported!
54 HeaderInfo id;
55 infile.read((char*)&(id.part0),SIZE_OF_INT);
56 infile.read((char*)&(id.part1),SIZE_OF_INT);
57 infile.read((char*)&(id.part2),SIZE_OF_INT);
58 infile.read((char*)&(id.part3),SIZE_OF_INT);
59
60 std::cout << "infoType: " << byteInfo << "\nheaderFormat: " << headerFormat << std::endl;
61 std::cout << "Part0: " << id.part0 <<
62 "\nPart1: " << id.part1 <<
63 "\nPart2: " << id.part2 <<
64 "\nPart3: " << id.part3 << std::endl;
65
66 _catalog->setHeaderInfo(id);
67 double minx,miny,maxx,maxy,stepx,stepy;
68 unsigned int xviews,yviews,nFragments;
69 if (headerFormat == 1795) // NormalDouble = 0x705
70 {
71
72 infile.read((char*)&(minx),SIZE_OF_DOUBLE);
73 _catalog->setXmin(minx);
74 infile.read((char*)&(maxx),SIZE_OF_DOUBLE);
75 _catalog->setXmax(maxx);
76 infile.read((char*)&(miny),SIZE_OF_DOUBLE);
77 _catalog->setYmin(miny);
78 infile.read((char*)&(maxy),SIZE_OF_DOUBLE);
79 _catalog->setYmax(maxy);
80 infile.read((char*)&(stepx),SIZE_OF_DOUBLE);
81 _catalog->setXstep(stepx);
82 infile.read((char*)&(stepy),SIZE_OF_DOUBLE);
83 _catalog->setYstep(stepy);
84 infile.read((char*)&(xviews),SIZE_OF_UNSIGNED_INT);
85 _catalog->setXviews(xviews);
86 infile.read((char*)&(yviews),SIZE_OF_UNSIGNED_INT);
87 _catalog->setYviews(yviews);
88 infile.read((char*)&(nFragments),SIZE_OF_UNSIGNED_INT);
89 _catalog->setNfragments(nFragments);
90 _catalog->initFragmentIndexes(yviews,xviews);
91 SetupStringRepresentation *set = _catalog->getSetup();
92 set->name = "Setup Info";
93 //unsigned char readUInt;
94 unsigned int readUInt;
95 infile.read((char*)&(readUInt),SIZE_OF_UNSIGNED_INT);
96 set->length = readUInt;
97 for (unsigned int i = 0; i < set->length; i++)
98 {
99 ConfigStringRepresentation cfg;
100 std::string className; infile.read((char*)(&className),64);
101 std::string name; infile.read((char*)(&name),64);
102 infile.read((char*)&(readUInt),SIZE_OF_UNSIGNED_INT);
103 cfg.className = className;
104 cfg.name = name;
105 cfg.length = readUInt;
106 std::cout << " === ClassName === \n\n" << className.c_str() <<
107 "\n\n ==== name === \n\n" << name.c_str() << std::endl;
108 for (unsigned int j=0; j<cfg.length; j++)
109 {
110 KeyStringRepresentation *keys = new KeyStringRepresentation();
111 std::string name; infile.read((char*)(&name),64);
112 std::string value; infile.read((char*)(&value),64);
113 keys->name = name;
114 keys->value = value;
115 cfg.keys.push_back(*keys);
116 }
117 }
118 for (unsigned int i = 0; i < _catalog->getXviews(); i++)
119 {
120 for (unsigned int j = 0; i < _catalog->getYviews(); j++)
121 {
122 unsigned int value; infile.read((char*)(&value),SIZE_OF_UNSIGNED_INT);
123 _catalog->setFragmentIndexes(j,i,value);
124 }
125 }
126 std::string reservedBytes; infile.read((char*)(&reservedBytes),256);
127
128 }
129 else // --- USED IN SCANGRID MODE ----
130 {
131 infile.read((char*)&(minx),SIZE_OF_INT);
132 _catalog->setXmin(minx);
133 infile.read((char*)&(maxx),SIZE_OF_INT);
134 _catalog->setXmax(maxx);
135 infile.read((char*)&(miny),SIZE_OF_INT);
136 _catalog->setYmin(miny);
137 infile.read((char*)&(maxy),SIZE_OF_INT);
138 _catalog->setYmax(maxy);
139 infile.read((char*)&(stepx),SIZE_OF_INT);
140 _catalog->setXstep(stepx);
141 infile.read((char*)&(stepy),SIZE_OF_INT);
142 _catalog->setYstep(stepy);
143 infile.read((char*)&(xviews),SIZE_OF_UNSIGNED_INT);
144 _catalog->setXviews(xviews);
145 infile.read((char*)&(yviews),SIZE_OF_UNSIGNED_INT);
146 _catalog->setYviews(yviews);
147 infile.read((char*)&(nFragments),SIZE_OF_UNSIGNED_INT);
148 _catalog->setNfragments(nFragments);
149 _catalog->initFragmentIndexes(yviews,xviews);
150 SetupStringRepresentation *set = _catalog->getSetup();
151 set->name = "Setup Info";
152 unsigned int readUInt;
153 infile.read((char*)&(readUInt),SIZE_OF_UNSIGNED_INT);
154 set->length = readUInt;
155 std::cout << "nFragments: " << nFragments << std::endl;
156 for (unsigned int i = 0; i < set->length; i++)
157 {
158 ConfigStringRepresentation cfg;
159 char className[65], name[65], value[65];
160 infile.read((char*)(&className),64);
161 infile.read((char*)(&name),64);
162 cfg.className = className;
163 cfg.name = name;
164 //long a;
165 unsigned int a;
166
167 infile.read((char*)&(a),4);
168 cfg.length = a;
169 //std::cout << "a: " << a << std::endl;
170
171 for (unsigned int j = 0; j < cfg.length; j++)
172 {
173
174 KeyStringRepresentation key;
175 infile.read((char*)(&name),64);
176 infile.read((char*)(&value),64);
177 key.name = name;
178 key.value = value;
179 cfg.keys.push_back(key);
180 }
181 set->configs.push_back(cfg);
182 }
183
184 for (unsigned int i = 0; i < _catalog->getYviews(); i++)
185 {
186 for (unsigned int j = 0; j < _catalog->getXviews(); j++)
187 {
188 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
189 _catalog->setFragmentIndexes(i,j,readUInt);
190
191 }
192
193 }
194 infile.seekg(256,std::ios::cur);
195 }
196 infile.close();
197 return true;
198}
SIZE_OF_CHAR
#define SIZE_OF_CHAR
Definition: ProcessRawData.h:23
SIZE_OF_UNSIGNED_SHORT_INT
#define SIZE_OF_UNSIGNED_SHORT_INT
Definition: ProcessRawData.h:25
SIZE_OF_DOUBLE
#define SIZE_OF_DOUBLE
Definition: ProcessRawData.h:27
SIZE_OF_INT
#define SIZE_OF_INT
Definition: ProcessRawData.h:24
SIZE_OF_UNSIGNED_INT
#define SIZE_OF_UNSIGNED_INT
Definition: ProcessRawData.h:26
a
void a()
Definition: check_aligned.C:59
Catalog::setNfragments
void setNfragments(unsigned int n)
Definition: Catalog.h:33
Catalog::getSetup
SetupStringRepresentation * getSetup()
Definition: Catalog.h:48
Catalog::setXmin
void setXmin(double xMin)
Definition: Catalog.h:27
Catalog::initFragmentIndexes
void initFragmentIndexes(unsigned int yviews, unsigned int xviews)
Definition: Catalog.h:23
Catalog::setFragmentIndexes
bool setFragmentIndexes(unsigned int y, unsigned int x, unsigned int value)
Definition: Catalog.cpp:13
Catalog::setHeaderInfo
void setHeaderInfo(HeaderInfo headerInfo)
Definition: Catalog.cpp:4
Catalog::setYmax
void setYmax(double yMax)
Definition: Catalog.h:30
Catalog::setXstep
void setXstep(double xStep)
Definition: Catalog.h:31
Catalog::setXviews
void setXviews(unsigned int x)
Definition: Catalog.h:25
Catalog::setYviews
void setYviews(unsigned int y)
Definition: Catalog.h:26
Catalog::setYmin
void setYmin(double yMin)
Definition: Catalog.h:29
Catalog::setXmax
void setXmax(double xMax)
Definition: Catalog.h:28
Catalog::setYstep
void setYstep(double yStep)
Definition: Catalog.h:32
ProcessRawData::initCatalog
void initCatalog()
Definition: ProcessRawData.cpp:20
set
EdbScanSet * set
Definition: emtraceback.cpp:14
name
const char * name
Definition: merge_Energy_SytematicSources_Electron.C:24
ConfigStringRepresentation
Definition: Struct.h:54
ConfigStringRepresentation::className
std::string className
Definition: Struct.h:55
ConfigStringRepresentation::length
unsigned int length
Definition: Struct.h:58
ConfigStringRepresentation::keys
std::vector< KeyStringRepresentation > keys
Definition: Struct.h:57
ConfigStringRepresentation::name
std::string name
Definition: Struct.h:56
HeaderInfo
Definition: Struct.h:20
KeyStringRepresentation
Definition: Struct.h:48
KeyStringRepresentation::name
std::string name
Definition: Struct.h:49
KeyStringRepresentation::value
std::string value
Definition: Struct.h:50
SetupStringRepresentation
Definition: Struct.h:62

◆ readFragment()

bool ProcessRawData::readFragment ( )
202{
203 initFragment();
204
205
206 View view;
207 std::vector<View> viewArr;
208 std::vector<Track> trackArr;
209
210
211 std::ifstream infile(_fragFileName.c_str(),std::ios::binary);
212 for(int i=0; i<5; i++) {
213 if (infile.fail()) {
214 infile.clear();
215 infile.open(_fragFileName.c_str(),std::ios::binary);
216 } else
217 break;
218 }
219 if (infile.fail())
220 {
221 std::cout << "Failed to open file: " << _fragFileName.c_str() << std::endl;
222 return false;
223 }
224 char infoType;
225 unsigned short headerFormat;
226 int codingMode;
227 unsigned int index, startView, nViews, fitCorrectionDataSize;
228
229 infile.read((char*)&infoType,SIZE_OF_CHAR);
230 infile.read((char*)&headerFormat,SIZE_OF_UNSIGNED_SHORT_INT);
231
232// if header && infotype da implementare
233 HeaderInfo id;
234 infile.read((char*)&id.part0,SIZE_OF_INT);
235 infile.read((char*)&id.part1,SIZE_OF_INT);
236 infile.read((char*)&id.part2,SIZE_OF_INT);
237 infile.read((char*)&id.part3,SIZE_OF_INT);
238 infile.read((char*)&index,SIZE_OF_UNSIGNED_INT);
239 infile.read((char*)&startView,SIZE_OF_UNSIGNED_INT);
240 infile.read((char*)&nViews,SIZE_OF_UNSIGNED_INT);
241 infile.read((char*)&fitCorrectionDataSize,SIZE_OF_UNSIGNED_INT);
242 infile.read((char*)&codingMode,SIZE_OF_INT);
243
244 _fragment->setId(id);
245 _fragment->setIndex(index);
246 _fragment->setStartView(startView);
247 _fragment->setViews(nViews);
248 _fragment->setFragmentCoding(codingMode);
249
250
251 if (!(codingMode == 0 || codingMode == 258)) // 0x0 == Normal, 0x102 == GrainSuppresion
252 {
253 std::cerr << "Unsupported fragment coding mode" << std::endl;
254 return -3;
255 }
256 infile.seekg(256,std::ios::cur);
257
258 if (headerFormat == 1795) // NormalDouble --> SCANGRID MODE
259 {
260 double readDouble;
261 int readInt;
262 char readChar;
263 for (unsigned int i = 0; i < nViews; i++)
264 {
265 view.setId(i);
266 Side topSide, bottomSide;
267 infile.read((char*)&readInt,SIZE_OF_INT);
268 view.setTileX(readInt);
269 infile.read((char*)&readInt,SIZE_OF_INT);
270 view.setTileY(readInt);
271 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
272 topSide.setStageFovPosX(readDouble);
273 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
274 bottomSide.setStageFovPosX(readDouble);
275 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
276 topSide.setStageFovPosY(readDouble);
277 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
278 bottomSide.setStageFovPosY(readDouble);
279 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
280 topSide.setMappedFovPosX(readDouble);
281 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
282 bottomSide.setMappedFovPosX(readDouble);
283 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
284 topSide.setMappedFovPosY(readDouble);
285 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
286 bottomSide.setMappedFovPosY(readDouble);
287
288 double mxx,mxy,myx,myy;
289 infile.read((char*)&mxx,SIZE_OF_DOUBLE);
290 infile.read((char*)&mxy,SIZE_OF_DOUBLE);
291 infile.read((char*)&myx,SIZE_OF_DOUBLE);
292 infile.read((char*)&myy,SIZE_OF_DOUBLE);
293 topSide.setM(mxx,mxy,myx,myy);
294 infile.read((char*)&mxx,SIZE_OF_DOUBLE);
295 infile.read((char*)&mxy,SIZE_OF_DOUBLE);
296 infile.read((char*)&myx,SIZE_OF_DOUBLE);
297 infile.read((char*)&myy,SIZE_OF_DOUBLE);
298 bottomSide.setM(mxx,mxy,myx,myy);
299 infile.read((char*)&readInt,SIZE_OF_INT);
300 topSide.setLayers(readInt);
301 infile.read((char*)&readInt,SIZE_OF_INT);
302 bottomSide.setLayers(readInt);
303 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
304 topSide.setTopZ(readDouble);
305 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
306 topSide.setBottomZ(readDouble);
307 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
308 bottomSide.setTopZ(readDouble);
309 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
310 bottomSide.setBottomZ(readDouble);
311
312 infile.read((char*)&readChar,SIZE_OF_CHAR);
313 topSide.setFlag(readChar);
314 infile.read((char*)&readChar,SIZE_OF_CHAR);
315 bottomSide.setFlag(readChar);
316
317 infile.read((char*)&readInt,SIZE_OF_INT);
318 topSide.setTracks(readInt);
319 infile.read((char*)&readInt,SIZE_OF_INT);
320 bottomSide.setTracks(readInt);
321
322 view.setTopSide(topSide);
323 view.setBottomSide(bottomSide);
324 viewArr.push_back(view);
325 }
326 for (unsigned int i = 0; i < nViews; i++)
327 {
328
329 for (int j = 0; j < viewArr.at(i).getTopSide()->getLayers(); j++)
330 {
331 unsigned int grains;
332 double z;
333 if(headerFormat == 1794 || headerFormat == 1795)
334 {
335 infile.read((char*)&grains,SIZE_OF_UNSIGNED_INT);
336 }
337 else
338 grains = 0;
339 infile.read((char*)&z,SIZE_OF_DOUBLE);
340 viewArr.at(i).getTopSide()->addLayer(grains,z);
341
342 }
343
344 for (int j = 0; j < viewArr.at(i).getBottomSide()->getLayers(); j++)
345 {
346
347 unsigned int grains;
348 double z;
349 if(headerFormat == 1794 || headerFormat == 1795)
350 {
351 infile.read((char*)&grains,SIZE_OF_UNSIGNED_INT);
352 }
353 else
354 grains = 0;
355 infile.read((char*)&z,SIZE_OF_DOUBLE);
356 viewArr.at(i).getBottomSide()->addLayer(grains,z);
357
358 }
359
360 }
361 for (unsigned int i = 0; i < nViews; i++)
362 {
363 Track tr;
364 unsigned int readUInt;
365 for (int j = 0; j < viewArr.at(i).getTopSide()->getTracks(); j++)
366 {
367
368 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
369 tr.setAreaSum(readUInt);
370 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
371 tr.setCount(static_cast<short>(readUInt));
372 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
373 tr.setX(readDouble);
374 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
375 tr.setY(readDouble);
376 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
377 tr.setZ(readDouble);
378 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
379 tr.setSX(readDouble);
380 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
381 tr.setSY(readDouble);
382 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
383 tr.setSZ(readDouble);
384 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
385 tr.setSigma(readDouble);
386 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
387 tr.setTopZ(readDouble);
388 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
389 tr.setBottomZ(readDouble);
390 viewArr.at(i).getTopSide()->addTrack(tr);
391
392 }
393 for (int j = 0; j < viewArr.at(i).getBottomSide()->getTracks(); j++)
394 {
395 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
396 tr.setAreaSum(readUInt);
397 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
398 tr.setCount(static_cast<short>(readUInt));
399 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
400 tr.setX(readDouble);
401 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
402 tr.setY(readDouble);
403 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
404 tr.setZ(readDouble);
405 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
406 tr.setSX(readDouble);
407 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
408 tr.setSY(readDouble);
409 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
410 tr.setSZ(readDouble);
411 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
412 tr.setSigma(readDouble);
413 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
414 tr.setTopZ(readDouble);
415 infile.read((char*)&readDouble,SIZE_OF_DOUBLE);
416 tr.setBottomZ(readDouble);
417 viewArr.at(i).getBottomSide()->addTrack(tr);
418 }
419 }
420 if (codingMode == 0)
421 {
422
423 for (unsigned int i = 0; i < nViews; i++)
424 {
425 for (int j = 0; j < viewArr.at(i).getTopSide()->getTracks(); j++)
426 {
427 Grain gr;
428 Track *tr = viewArr.at(i).getTopSide()->getTrackAt(j);
429 for (int k = 0; k < tr->getCount(); k++)
430 {
431 if (headerFormat == 1795)
432 {
433 unsigned int readUInt;
434 infile.read((char*)&readUInt,4);
435 gr.area = readUInt;
436 }
437 else
438 gr.area = 0;
439 infile.read((char*)&readDouble,8);
440 gr.x = readDouble;
441 infile.read((char*)&readDouble,8);
442 gr.y = readDouble;
443 infile.read((char*)&readDouble,8);
444 gr.z = readDouble;
445 tr->addGrain(gr);
446 }
447 if (_filterTracks)
448 tr->evaluateEstimators();
449 }
450 for (int j = 0; j < viewArr.at(i).getBottomSide()->getTracks(); j++)
451 {
452 Grain gr;
453 Track *tr = viewArr.at(i).getBottomSide()->getTrackAt(j);
454 for (int k = 0; k < tr->getCount(); k++)
455 {
456 if (headerFormat == 1795)
457 {
458 unsigned int readUInt;
459 infile.read((char*)&readUInt,4);
460 gr.area = readUInt;
461 }
462 else
463 gr.area = 0;
464 infile.read((char*)&readDouble,8);
465 gr.x = readDouble;
466 infile.read((char*)&readDouble,8);
467 gr.y = readDouble;
468 infile.read((char*)&readDouble,8);
469 gr.z = readDouble;
470 tr->addGrain(gr);
471 }
472 if (_filterTracks)
473 tr->evaluateEstimators();
474 }
475 }
476 }
477 }
478 else
479 {
480
481
482 float readFloat;
483 int readInt;
484
485
486
487 for (unsigned int i = 0; i < nViews; i++)
488 {
489 view.setId(i);
490 Side topSide, bottomSide;
491 infile.read((char*)&readInt,SIZE_OF_INT);
492 view.setTileX(readInt);
493 infile.read((char*)&readInt,SIZE_OF_INT);
494 view.setTileY(readInt);
495
496
497 infile.read((char*)&readFloat,4);
498 topSide.setStageFovPosX(readFloat);
499 infile.read((char*)&readFloat,4);
500 bottomSide.setStageFovPosX(readFloat);
501 infile.read((char*)&readFloat,4);
502 topSide.setStageFovPosY(readFloat);
503 infile.read((char*)&readFloat,4);
504 bottomSide.setStageFovPosY(readFloat);
505 infile.read((char*)&readFloat,4);
506 topSide.setMappedFovPosX(readFloat);
507 infile.read((char*)&readFloat,4);
508 bottomSide.setMappedFovPosX(readFloat);
509 infile.read((char*)&readFloat,4);
510 topSide.setMappedFovPosY(readFloat);
511 infile.read((char*)&readFloat,4);
512 bottomSide.setMappedFovPosY(readFloat);
513
514 float mxx4bytes,mxy4bytes,myx4bytes,myy4bytes;
515 infile.read((char*)&mxx4bytes,4);
516 infile.read((char*)&mxy4bytes,4);
517 infile.read((char*)&myx4bytes,4);
518 infile.read((char*)&myy4bytes,4);
519 topSide.setM(mxx4bytes,mxy4bytes,myx4bytes,myy4bytes);
520
521 infile.read((char*)&mxx4bytes,4);
522 infile.read((char*)&mxy4bytes,4);
523 infile.read((char*)&myx4bytes,4);
524 infile.read((char*)&myy4bytes,4);
525 bottomSide.setM(mxx4bytes,mxy4bytes,myx4bytes,myy4bytes);
526
527 infile.read((char*)&readInt,SIZE_OF_INT);
528 topSide.setLayers(readInt);
529 infile.read((char*)&readInt,SIZE_OF_INT);
530 bottomSide.setLayers(readInt);
531
532
533 infile.read((char*)&readFloat,4);
534 topSide.setTopZ(readFloat);
535 infile.read((char*)&readFloat,4);
536 topSide.setBottomZ(readFloat);
537 infile.read((char*)&readFloat,4);
538 bottomSide.setTopZ(readFloat);
539 infile.read((char*)&readFloat,4);
540 bottomSide.setBottomZ(readFloat);
541
542 unsigned int readUInt;
543 infile.read((char*)&readUInt,SIZE_OF_CHAR);
544 topSide.setFlag(readUInt);
545 infile.read((char*)&readUInt,SIZE_OF_CHAR);
546 bottomSide.setFlag(readUInt);
547
548 infile.read((char*)&readInt,SIZE_OF_INT);
549 topSide.setTracks(readInt);
550 infile.read((char*)&readInt,SIZE_OF_INT);
551 bottomSide.setTracks(readInt);
552
553 view.setTopSide(topSide);
554 view.setBottomSide(bottomSide);
555 viewArr.push_back(view);
556 }
557 for (unsigned int i = 0; i < nViews; i++)
558 {
559
560 for (int j = 0; j < viewArr.at(i).getTopSide()->getLayers(); j++)
561 {
562 unsigned int grains;
563 double z;
564 if(headerFormat == 1794 || headerFormat == 1795)
565 {
566 infile.read((char*)&grains,SIZE_OF_UNSIGNED_INT);
567 }
568 else
569 grains = 0;
570 infile.read((char*)&readFloat,4);
571 z = readFloat;
572 viewArr.at(i).getTopSide()->addLayer(grains,z);
573
574 }
575
576 for (int j = 0; j < viewArr.at(i).getBottomSide()->getLayers(); j++)
577 {
578
579 unsigned int grains;
580 double z;
581 if(headerFormat == 1794 || headerFormat == 1795)
582 {
583 infile.read((char*)&grains,SIZE_OF_UNSIGNED_INT);
584 }
585 else
586 grains = 0;
587 infile.read((char*)&readFloat,4);
588 z = readFloat;
589 viewArr.at(i).getBottomSide()->addLayer(grains,z);
590
591 }
592
593 }
594 for (unsigned int i = 0; i < nViews; i++)
595 {
596 Track tr;
597 unsigned int readUInt;
598 for (int j = 0; j < viewArr.at(i).getTopSide()->getTracks(); j++)
599 {
600
601 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
602 tr.setAreaSum(readUInt);
603 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
604 tr.setCount(static_cast<short>(readUInt));
605
606 infile.read((char*)&readFloat,4);
607 tr.setX(readFloat);
608 infile.read((char*)&readFloat,4);
609 tr.setY(readFloat);
610 infile.read((char*)&readFloat,4);
611 tr.setZ(readFloat);
612 infile.read((char*)&readFloat,4);
613 tr.setSX(readFloat);
614 infile.read((char*)&readFloat,4);
615 tr.setSY(readFloat);
616 infile.read((char*)&readFloat,4);
617 tr.setSZ(readFloat);
618 infile.read((char*)&readFloat,4);
619 tr.setSigma(readFloat);
620 infile.read((char*)&readFloat,4);
621 tr.setTopZ(readFloat);
622 infile.read((char*)&readFloat,4);
623 tr.setBottomZ(readFloat);
624 if(headerFormat == 1793) //old format
625 {
626 infile.read((char*)&readFloat,4);infile.read((char*)&readFloat,4);
627 infile.read((char*)&readFloat,4);infile.read((char*)&readFloat,4);
628 infile.read((char*)&readFloat,4);infile.read((char*)&readFloat,4);
629 infile.read((char*)&readFloat,SIZE_OF_UNSIGNED_INT);
630
631 }
632 viewArr.at(i).getTopSide()->addTrack(tr);
633
634
635 }
636 for (int j = 0; j < viewArr.at(i).getBottomSide()->getTracks(); j++)
637 {
638
639 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
640 tr.setAreaSum(readUInt);
641 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
642 tr.setCount(static_cast<short>(readUInt));
643
644 infile.read((char*)&readFloat,4);
645 tr.setX(readFloat);
646 infile.read((char*)&readFloat,4);
647 tr.setY(readFloat);
648 infile.read((char*)&readFloat,4);
649 tr.setZ(readFloat);
650 infile.read((char*)&readFloat,4);
651 tr.setSX(readFloat);
652 infile.read((char*)&readFloat,4);
653 tr.setSY(readFloat);
654 infile.read((char*)&readFloat,4);
655 tr.setSZ(readFloat);
656 infile.read((char*)&readFloat,4);
657 tr.setSigma(readFloat);
658 infile.read((char*)&readFloat,4);
659 tr.setTopZ(readFloat);
660 infile.read((char*)&readFloat,4);
661 tr.setBottomZ(readFloat);
662 if(headerFormat == 1793) //old format
663 {
664 infile.read((char*)&readFloat,4);infile.read((char*)&readFloat,4);
665 infile.read((char*)&readFloat,4);infile.read((char*)&readFloat,4);
666 infile.read((char*)&readFloat,4);infile.read((char*)&readFloat,4);
667 infile.read((char*)&readFloat,SIZE_OF_UNSIGNED_INT);
668
669 }
670 viewArr.at(i).getBottomSide()->addTrack(tr);
671
672 }
673 }
674 if (codingMode == 0)
675 {
676 for (unsigned int i = 0; i < nViews; i++)
677 {
678 for (int j = 0; j < viewArr.at(i).getTopSide()->getTracks(); j++)
679 {
680 Grain gr;
681 Track *tr = viewArr.at(i).getTopSide()->getTrackAt(j);
682 for (int k = 0; k < tr->getCount(); k++)
683 {
684 if (headerFormat == 1794)
685 {
686 unsigned int readUInt;
687 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
688 gr.area = readUInt;
689 }
690 else
691 gr.area = 0;
692 infile.read((char*)&readFloat,4);
693 gr.x = readFloat;
694 infile.read((char*)&readFloat,4);
695 gr.y = readFloat;
696 infile.read((char*)&readFloat,4);
697 gr.z = readFloat;
698 tr->addGrain(gr);
699 }
700 if (_filterTracks)
701 tr->evaluateEstimators();
702
703 }
704 for (int j = 0; j < viewArr.at(i).getBottomSide()->getTracks(); j++)
705 {
706 Grain gr;
707 Track *tr = viewArr.at(i).getBottomSide()->getTrackAt(j);
708 for (int k = 0; k < tr->getCount(); k++)
709 {
710 if (headerFormat == 1794)
711 {
712 unsigned int readUInt;
713 infile.read((char*)&readUInt,SIZE_OF_UNSIGNED_INT);
714 gr.area = readUInt;
715 }
716 else
717 gr.area = 0;
718 infile.read((char*)&readFloat,4);
719 gr.x = readFloat;
720 infile.read((char*)&readFloat,4);
721 gr.y = readFloat;
722 infile.read((char*)&readFloat,4);
723 gr.z = readFloat;
724 tr->addGrain(gr);
725 }
726 if (_filterTracks)
727 tr->evaluateEstimators();
728
729 }
730 }
731
732
733 }
734 }
735 _fragment->setViewsArray(viewArr);
736
737 infile.close();
738 return true;
739
740}
Fragment::setViewsArray
void setViewsArray(std::vector< View > vArr)
Definition: Fragment.cpp:13
Fragment::setFragmentCoding
void setFragmentCoding(int fragmentCoding)
Definition: Fragment.h:23
Fragment::setId
void setId(HeaderInfo id)
Definition: Fragment.cpp:22
Fragment::setStartView
void setStartView(unsigned int startView)
Definition: Fragment.h:25
Fragment::setViews
void setViews(int nViews)
Definition: Fragment.h:26
Fragment::setIndex
void setIndex(unsigned int index)
Definition: Fragment.h:24
ProcessRawData::initFragment
void initFragment()
Definition: ProcessRawData.cpp:26
Side::setLayers
void setLayers(int nLayers)
Definition: Side.h:46
Side::setBottomZ
void setBottomZ(double bottomZ)
Definition: Side.h:37
Side::setTopZ
void setTopZ(double topZ)
Definition: Side.h:36
Side::setMappedFovPosY
void setMappedFovPosY(double posy)
Definition: Side.h:42
Side::setTracks
void setTracks(int nTracks)
Definition: Side.h:44
Side::setM
void setM(double mxx, double mxy, double myx, double myy)
Definition: Side.cpp:45
Side::setFlag
void setFlag(int flag)
Definition: Side.h:45
Side::setMappedFovPosX
void setMappedFovPosX(double posx)
Definition: Side.h:41
Side::setStageFovPosX
void setStageFovPosX(double posx)
Definition: Side.h:39
Side::setStageFovPosY
void setStageFovPosY(double posy)
Definition: Side.h:40
View::setTopSide
void setTopSide(Side side)
Definition: View.h:39
View::setId
void setId(int id)
Definition: View.h:41
View::setTileY
void setTileY(int y)
Definition: View.h:48
View::setBottomSide
void setBottomSide(Side side)
Definition: View.h:40
View::setTileX
void setTileX(int x)
Definition: View.h:47
grains
grains()
Definition: grains.C:3
Grain
Definition: Struct.h:33
Grain::y
double y
Definition: Struct.h:36
Grain::x
double x
Definition: Struct.h:35
Grain::area
unsigned short area
Definition: Struct.h:34
Grain::z
double z
Definition: Struct.h:37

◆ setCatalogName()

void ProcessRawData::setCatalogName ( std::string  fileName)
inline
48{_catFileName = fileName;}

◆ setClOption()

void ProcessRawData::setClOption ( bool  noCl)
inline
51{_clusters = noCl;}

◆ setFilterTrackOption()

void ProcessRawData::setFilterTrackOption ( bool  filterTracks)
inline
52{_filterTracks = filterTracks;}

◆ setFragmentName()

void ProcessRawData::setFragmentName ( std::string  fileName)
inline
49{_fragFileName = fileName;}

◆ setRootName()

void ProcessRawData::setRootName ( std::string  fileName)
inline
50{_outputRootFileName = fileName;}

Member Data Documentation

◆ _catalog

Catalog* ProcessRawData::_catalog
private

◆ _catFileName

std::string ProcessRawData::_catFileName
private

◆ _clusters

bool ProcessRawData::_clusters
private

◆ _filterTracks

bool ProcessRawData::_filterTracks
private

◆ _fragFileName

std::string ProcessRawData::_fragFileName
private

◆ _fragment

Fragment* ProcessRawData::_fragment
private

◆ _outputRootFileName

std::string ProcessRawData::_outputRootFileName
private

◆ _run

EdbRun* ProcessRawData::_run
private
The documentation for this class was generated from the following files: