EdbRun Class Reference

#include <EdbRun.h>

Inheritance diagram for EdbRun:

Collaboration diagram for EdbRun:

Public Member Functions
int	AddAsciiFile (const char *fname, const char *objname)
void	AddFrameAlign (Int_t frame1, Int_t frame2, Int_t view, Int_t area, Int_t side, Float_t dxglobal, Float_t dyglobal, Float_t dx, Float_t dy, Float_t z1, Float_t z2, Int_t n1tot, Int_t n2tot, Int_t n1, Int_t n2, Int_t nsg, Int_t nbg, Int_t flag)
void	AddPinViewHeader (EdbViewHeader &h)
void	AddView ()
void	AddView (EdbView *view)
void	AddViewAlign (Int_t view1, Int_t view2, Int_t area1, Int_t area2, Int_t side1, Int_t side2, Float_t dx, Float_t dy, Float_t dz, Int_t n1tot, Int_t n2tot, Int_t n1, Int_t n2, Int_t nsg, Int_t nbg, Int_t flag, EdbViewHeader &vh1, EdbViewHeader &vh2)
void	AddViewMerge (Int_t view1, Int_t view2, Int_t area1, Int_t area2, Int_t side1, Int_t side2, Float_t dx, Float_t dy, Float_t dz, Int_t n1tot, Int_t n2tot, Int_t n1, Int_t n2, Int_t nsg, Int_t nbg, Int_t flag)
void	Close ()
void	Create (const char *fname)
	EdbRun ()
	EdbRun (const char *fname, const char *status="READ")
	EdbRun (EdbRun &run, const char *fname)
	EdbRun (int id, const char *status="READ", const char *path=".")
int	ExtractAsciiFile (const char *fname, const char *objname)
void	GeneratePredictions (int n)
int	GetEntries () const
EdbView *	GetEntry (int entry, int ih=1, int icl=0, int iseg=1, int itr=0, int ifr=0)
TClonesArray *	GetEntryClusters (int entry) const
TObjArray *	GetEntryFrames (int entry) const
EdbViewHeader *	GetEntryHeader (int entry) const
int	GetEntryNumberWithIndex (int event, int view) const
TClonesArray *	GetEntrySegments (int entry) const
TClonesArray *	GetEntryTracks (int entry) const
TFile *	GetFile ()
TDatime *	GetFinishTime () const
EdbRunHeader *	GetHeader () const
EdbMarksSet *	GetMarks () const
TTree *	GetPinViews () const
EdbPredictionDC *	GetPrediction (int ip)
EdbPredictionsBox *	GetPredictions () const
int	GetRunID () const
TDatime *	GetStartTime () const
TTree *	GetTree () const
EdbView *	GetView () const
void	Init ()
int	Npredictions () const
void	Open (const char *fname)
void	OpenUpdate (const char *fname)
void	Print () const
void	PrintBranchesStatus () const
void	PrintLog (const char *fname) const
void	Save ()
void	SaveViews ()
void	SelectOpenMode (const char *fname, const char *status="READ")
void	SetComment (const char *com)
void	SetMarks (EdbMarksSet *marks)
void	SetRunID (int id)
void	SetTitle (const char *tit)
void	SetView ()
void	SetView (EdbView *view)
void	TransformDC ()
virtual	~EdbRun ()

Public Attributes
EdbMarksSet *	eMarks

Private Attributes
AlignmentParFrame	eFA
TFile *	eFile
TTree *	eFrameAlign
EdbRunHeader *	eHeader
TString	ePath
TTree *	ePinViews
EdbPredictionsBox *	ePredictions
EdbViewHeader *	ePVH
TTree *	eTree
AlignmentParView	eVA
EdbViewHeader *	eVH1
EdbViewHeader *	eVH2
EdbView *	eView
TTree *	eViewAlign
TTree *	eViewMerge
AlignmentParView	eVM

Constructor & Destructor Documentation

EdbRun() [1/4]

EdbRun::EdbRun

(

)

EdbRun() [2/4]

EdbRun::EdbRun	(	int	id,
		const char *	status = "READ",
		const char *	path = "."
	)

{
  Init();
 
  eHeader        = new EdbRunHeader(id);
 
  ePath = path;
 
  char fname[256]="";
  sprintf(fname,"%s/run%4.4d.root",path,id);
 
  SelectOpenMode( fname, status );
}

EdbRun() [3/4]

EdbRun::EdbRun	(	const char *	fname,
		const char *	status = "READ"
	)

{
  Init();
 
  eHeader        = new EdbRunHeader(0);
 
  SelectOpenMode( fname, status );
}

EdbRun() [4/4]

EdbRun::EdbRun	(	EdbRun &	run,
		const char *	fname
	)

{
  Init();
 
  if(run.GetHeader()) 
    eHeader = new EdbRunHeader(*(run.GetHeader()));
  if(run.GetMarks())  
    eMarks  = new EdbMarksSet(*(run.GetMarks()));
  if(run.GetPredictions())  
    ePredictions  = new EdbPredictionsBox(*(run.GetPredictions()));
  Log(3,"EdbRun::EdbRun","Run headers are copied");
  SelectOpenMode( fname, "RECREATE" );
}

~EdbRun()

EdbRun::~EdbRun ( )

virtual

{
  //SafeDelete(eTree);
 
  SafeDelete(eFile); 
  SafeDelete(eHeader);
  SafeDelete(ePredictions);
  SafeDelete(eMarks);
 
  //SafeDelete(eView);    // provocate crash in EdbRunAccess::CopyRawDataXY  - to understand!
/*
    if(ePVH)
        SafeDelete(ePVH);
    if(eVH1)
        SafeDelete(eVH1);
    if(eVH2)
        SafeDelete(eVH2);
*/
}

Member Function Documentation

AddAsciiFile()

int EdbRun::AddAsciiFile	(	const char *	fname,
		const char *	objname
	)

{
  // can be used for reading  relativly small ascii files from fname and 
  // save into the current run with name objname as TObjString
 
  FILE *fp=fopen(fname,"r");
  if (fp==NULL)   {
    printf("ERROR open file: %s n", fname);    return(-1);
  }else
    printf( "Read Ascii file: %s\n", fname );
  TObjString  str;
  char     buf[256];
  while( fgets(buf,256,fp)!=NULL ) str.String().Append(buf);
  fclose(fp);
  return  str.Write(objname);
}

AddFrameAlign()

void EdbRun::AddFrameAlign	(	Int_t	frame1,
		Int_t	frame2,
		Int_t	view,
		Int_t	area,
		Int_t	side,
		Float_t	dxglobal,
		Float_t	dyglobal,
		Float_t	dx,
		Float_t	dy,
		Float_t	z1,
		Float_t	z2,
		Int_t	n1tot,
		Int_t	n2tot,
		Int_t	n1,
		Int_t	n2,
		Int_t	nsg,
		Int_t	nbg,
		Int_t	flag
	)

{
  if(!eFrameAlign) {
    eFrameAlign = new TTree("FrameAlign","Neighbour frames offsets");
        eFrameAlign->Branch("frpar",&eFA,"frame1/I:frame2/I:view/I:area/I:side/I:dxglobal/F:dyglobal/F:dx/F:dy/F:z1/F:z2/F:n1tot/I:n2tot/I:n1/I:n2/I:nsg/I:nbg/I:flag/I");
  }
  if(eFrameAlign) {
    eFA.frame1=frame1; eFA.frame2=frame2;
        eFA.view=view;
        eFA.area=area;
        eFA.side=side;
        eFA.dxglobal=dxglobal;
        eFA.dyglobal=dyglobal;
        eFA.dx=dx;   eFA.dy=dy; 
        eFA.z1=z1;   eFA.z2=z2;
    eFA.n1tot=n1tot; eFA.n2tot=n2tot;
    eFA.n1=n1; eFA.n2=n2;
    eFA.nsg=nsg; eFA.nbg=nbg;
    eFA.flag=flag;
    eFrameAlign->Fill();
  }
}

AddPinViewHeader()

void EdbRun::AddPinViewHeader

(

EdbViewHeader &

h

)

{
  if(!ePinViews) {
    ePinViews = new TTree("PinViews","Pinned Views");
    ePinViews->Branch("headers","EdbViewHeader",&ePVH);
  }
  if(ePinViews) {
    *ePVH=h;
    ePinViews->Fill();
  }
}

AddView() [1/2]

void EdbRun::AddView

(

)

{
  AddView(eView);
}

AddView() [2/2]

void EdbRun::AddView

(

EdbView *

view

)

{
 
  if( view != eView ) { 
    Log(3," EdbRun::AddView","WARNING: view!=eView - inefficient cycle!");
    SetView(view);
  }
 
  EdbViewHeader *viewHeader = eView->GetHeader();
 
  //Long_t oldtime = eView->GetLastSystemTime();
  //Long_t newtime = gSystem->Now(); 
  //viewHeader->SetTime( (Int_t)((ULong_t)newtime-(ULong_t)oldtime) );
  //eView->SetLastSystemTime(newtime);
 
  viewHeader->SetNclusters(eView->Nclusters());
  viewHeader->SetNsegments(eView->Nsegments());
  viewHeader->SetEvent( GetHeader()->GetFlag(8) );
  viewHeader->SetTrack( GetHeader()->GetFlag(9) );
 
  eTree->Fill();
  eView->Clear();
}

AddViewAlign()

void EdbRun::AddViewAlign	(	Int_t	view1,
		Int_t	view2,
		Int_t	area1,
		Int_t	area2,
		Int_t	side1,
		Int_t	side2,
		Float_t	dx,
		Float_t	dy,
		Float_t	dz,
		Int_t	n1tot,
		Int_t	n2tot,
		Int_t	n1,
		Int_t	n2,
		Int_t	nsg,
		Int_t	nbg,
		Int_t	flag,
		EdbViewHeader &	vh1,
		EdbViewHeader &	vh2
	)

{
  if(!eViewAlign) {
    eViewAlign = new TTree("ViewAlign","Alignment offsets");
        eViewAlign->Branch("alpar",&eVA,"view1/I:view2/I:area1/I:area2/I:side1/I:side2/I:dx/F:dy/F:dz/F:n1tot/I:n2tot/I:n1/I:n2/I:nsg/I:nbg/I:flag/I");
    eViewAlign->Branch("vh1","EdbViewHeader",&eVH1);
    eViewAlign->Branch("vh2","EdbViewHeader",&eVH2);
  }
  if(eViewAlign) {
    eVA.view1=view1; eVA.view2=view2;
    eVA.area1=area1; eVA.area2=area2;
    eVA.side1=side1; eVA.side2=side2;
    eVA.dx=dx;   eVA.dy=dy; eVA.dz=dz;
    eVA.n1tot=n1tot; eVA.n2tot=n2tot;
    eVA.n1=n1; eVA.n2=n2;
    eVA.nsg=nsg; eVA.nbg=nbg;
    eVA.flag=flag;
    *eVH1=vh1;
    *eVH2=vh2;
    eViewAlign->Fill();
  }
}

AddViewMerge()

void EdbRun::AddViewMerge	(	Int_t	view1,
		Int_t	view2,
		Int_t	area1,
		Int_t	area2,
		Int_t	side1,
		Int_t	side2,
		Float_t	dx,
		Float_t	dy,
		Float_t	dz,
		Int_t	n1tot,
		Int_t	n2tot,
		Int_t	n1,
		Int_t	n2,
		Int_t	nsg,
		Int_t	nbg,
		Int_t	flag
	)

{
  if(!eViewMerge) {
    eViewMerge = new TTree("ViewMerge","Merging offsets");
        eViewMerge->Branch("alpar",&eVM,"view1/I:view2/I:area1/I:area2/I:side1/I:side2/I:dx/F:dy/F:dz/F:n1tot/I:n2tot/I:n1/I:n2/I:nsg/I:nbg/I:flag/I");
  }
  if(eViewMerge) {
    eVM.view1=view1; eVM.view2=view2;
    eVM.area1=area1; eVM.area2=area2;
    eVM.side1=side1; eVM.side2=side2;
    eVM.dx=dx;   eVM.dy=dy; eVM.dz=dz;
    eVM.n1tot=n1tot; eVM.n2tot=n2tot;
    eVM.n1=n1; eVM.n2=n2;
    eVM.nsg=nsg; eVM.nbg=nbg;
    eVM.flag=flag;
    eViewMerge->Fill();
  }
}

Close()

void EdbRun::Close

(

)

{
  eFile = eTree->GetCurrentFile();
  const char *status = eFile->GetOption();
 
  GetFile()->cd();
  if(eHeader) eHeader->GetFinishTime()->Set();
 
  if( strcmp(status,"READ") ) {             // file is in "write" mode
    if( !strcmp(status,"CREATE") ) {        // save header in CREATE mode only
      Save();
    }
    if(eTree)          eTree->Write();
    if(eViewMerge)     eViewMerge->Write();
    if(eViewAlign)     eViewAlign->Write();
    if(eFrameAlign)    eFrameAlign->Write();
    if(ePinViews)      ePinViews->Write();
  }
  eFile->Purge();
  eFile->Close();
}

Create()

void EdbRun::Create

(

const char *

fname

)

{
  // Check if the file already exists
  if (!gSystem->AccessPathName(fname, kFileExists)) {
    Log(1, "EdbRun::Create", "WARNING: File %s already exists!", fname);
//    return;
  }    
  // Check if the directory exists and is writable
  TString dirPath = gSystem->DirName(fname);
  if (gSystem->AccessPathName(dirPath, kFileExists)) {
    Log(1, "EdbRun::Create", "ERROR! Directory does not exist: %s", dirPath.Data());
    return;
  }
  // Create the file (handles remote paths)
  eFile = TFile::Open(fname, "RECREATE");
  if (!eFile || eFile->IsZombie()) {
    Log(1, "EdbRun::Create", "ERROR! Failed to open file: %s (IsZomby)", fname);
    return;
  }
  // Initialize predictions and marks
  if (!ePredictions) ePredictions = new EdbPredictionsBox();
  if (!eMarks) eMarks = new EdbMarksSet();
 
  eFile->SetCompressionLevel(2);  
  // Create the tree
  eTree = new TTree("Views", "Scanning Views data");
  eTree->SetAutoSave(-100000000);  // Autosave each 100MB
  eTree->SetMaxTreeSize(512000000000LL);  // Set 512GB file size limit
  Log(3, "EdbRun::Create", "Set max tree size as: %lld", eTree->GetMaxTreeSize());
  
  // Create branches
  TClonesArray *eClusters = eView->GetClusters();
  TClonesArray *eSegments = eView->GetSegments();
  TClonesArray *eTracks = eView->GetTracks();
  TClonesArray *eFrames = eView->GetFrames();
  
  int savelevel = gErrorIgnoreLevel;
  gErrorIgnoreLevel = kError;
  eTree->Branch("clusters", &eClusters);
  eTree->Branch("segments", &eSegments);
  eTree->Branch("tracks",   &eTracks);
  eTree->Branch("frames",   &eFrames);
  eTree->Branch("headers", "EdbViewHeader", eView->GetHeaderAddr(), 32000, 99);
  gErrorIgnoreLevel = savelevel;
  
  SetView();
  Log(2, "EdbRun::Create", "Successfully created file: %s", fname);
}

ExtractAsciiFile()

int EdbRun::ExtractAsciiFile	(	const char *	fname,
		const char *	objname
	)

{
  FILE *fp=fopen(fname,"w");
  if (fp==NULL)   {
    printf("ERROR open file: %s n", fname);    return(-1);
  }else
    printf( "Write to Ascii file: %s\n", fname );
  TObjString  *str=(TObjString *)(eFile->Get(objname));
  fprintf(fp,"%s",str->String().Data());
  fclose(fp);
  return  str->String().Sizeof();
}

GeneratePredictions()

void EdbRun::GeneratePredictions

(

int

n

)

{
  if(!ePredictions)    ePredictions = new EdbPredictionsBox(n);
 
  ePredictions->Generate(n);
}

GetEntries()

int EdbRun::GetEntries ( ) const

inline

{ return (Int_t)eTree->GetEntries(); }

GetEntry()

EdbView * EdbRun::GetEntry	(	int	entry,
		int	ih = 1,
		int	icl = 0,
		int	iseg = 1,
		int	itr = 0,
		int	ifr = 0
	)

{
  if(eView)     eView->Clear();
  else          SetView();
 
  if( !eView->GetClusters() )  SetView();
 
  if(ih)   GetEntryHeader(   entry );
  if(icl)  GetEntryClusters( entry );
  if(iseg) GetEntrySegments( entry );
  if(itr)  GetEntryTracks(   entry );
  if(ifr)  GetEntryFrames(   entry );
 
  return eView;
}

GetEntryClusters()

TClonesArray * EdbRun::GetEntryClusters

(

int

entry

)

const

{
  TClonesArray *clusters = eView->GetClusters();
  TBranchClones *clustersBranch = (TBranchClones*)(eTree->GetBranch("clusters"));
  if(!clustersBranch)                                            return 0;
  //clustersBranch->SetAutoDelete( kTRUE );
  clustersBranch->ResetReadEntry();
  clustersBranch->SetAddress(&clusters);
  clustersBranch->GetEntry(entry);
 
  return clusters;
}

GetEntryFrames()

TObjArray * EdbRun::GetEntryFrames

(

int

entry

)

const

{
  TObjArray *frames = eView->GetFrames();
  TBranch *framesBranch = eTree->GetBranch("frames");
  if(!framesBranch)                                            return 0;
  framesBranch->SetAddress(&frames);
  framesBranch->GetEntry(entry);
 
  return frames;
}

GetEntryHeader()

EdbViewHeader * EdbRun::GetEntryHeader

(

int

entry

)

const

{
  EdbViewHeader *header = eView->GetHeader();
  TBranch *headerBranch = eTree->GetBranch("headers");
  if(!headerBranch)                                            return 0;
  headerBranch->SetAddress(&header);
  headerBranch->GetEntry(entry);
  //  eTree->GetEntry(entry);
 
  return header;
}

GetEntryNumberWithIndex()

int EdbRun::GetEntryNumberWithIndex ( int  event, int  view  ) const

inline

    { return eTree->GetEntryNumberWithIndex( event,view ); }

GetEntrySegments()

TClonesArray * EdbRun::GetEntrySegments

(

int

entry

)

const

{
  TClonesArray *segments = eView->GetSegments();
  TBranchClones *segmentsBranch = (TBranchClones*)(eTree->GetBranch("segments"));
  if(!segmentsBranch)                                            return 0;
 
  segmentsBranch->ResetReadEntry();
  segmentsBranch->SetAddress(&segments);
  segmentsBranch->GetEntry(entry);
 
  return segments;
}

GetEntryTracks()

TClonesArray * EdbRun::GetEntryTracks

(

int

entry

)

const

{
  TClonesArray  *tracks=eView->GetTracks();
  TBranchClones *tracksBranch = (TBranchClones*)(eTree->GetBranch("tracks"));
  if(!tracksBranch)                                            return 0;
 
  tracksBranch->ResetReadEntry();
  tracksBranch->SetAddress(&tracks);
  tracksBranch->GetEntry(entry);
 
  return tracks;
}

GetFile()

TFile* EdbRun::GetFile ( )

inline

{ return eFile; }

GetFinishTime()

TDatime* EdbRun::GetFinishTime ( ) const

inline

{ return eHeader->GetFinishTime();  }

GetHeader()

EdbRunHeader* EdbRun::GetHeader ( ) const

inline

{ return eHeader; }

GetMarks()

EdbMarksSet* EdbRun::GetMarks ( ) const

inline

{ return eMarks; }

GetPinViews()

TTree* EdbRun::GetPinViews ( ) const

inline

{return ePinViews;}

GetPrediction()

EdbPredictionDC* EdbRun::GetPrediction ( int  ip )

inline

{ return ePredictions->GetPrediction(ip); }

GetPredictions()

EdbPredictionsBox* EdbRun::GetPredictions ( ) const

inline

{ return ePredictions; }

GetRunID()

int EdbRun::GetRunID ( ) const

inline

{ return eHeader->GetRunID();     }

GetStartTime()

TDatime* EdbRun::GetStartTime ( ) const

inline

{ return eHeader->GetStartTime();  }

GetTree()

TTree* EdbRun::GetTree ( ) const

inline

{return eTree; }

GetView()

EdbView* EdbRun::GetView ( ) const

inline

{ return eView; }

Init()

void EdbRun::Init

(

void

)

{
  eView        = new EdbView();      //each run has his own view
  eHeader      = 0;
  eTree        = 0;
  eFile        = 0;
  ePath        = "";
  ePredictions = 0;
  eMarks       = 0;
  eViewMerge   = 0;
  eViewAlign   = 0;
  eFrameAlign  = 0;
  ePinViews    = 0;
  ePVH=new EdbViewHeader();
    eVH1=new EdbViewHeader();
    eVH2=new EdbViewHeader();
}

Npredictions()

int EdbRun::Npredictions ( ) const

inline

{ return ePredictions->N(); }

Open()

void EdbRun::Open

(

const char *

fname

)

{
  Log(3,"EdbRun::Open","Open an existing file %s for reading", fname);
  eFile = TFile::Open(fname,"READ");
  if (!eFile || eFile->IsZombie()) {
    Log(1, "EdbRun::OpenUpdate", "ERROR! Failed to open file: %s", fname);
    SafeDelete(eFile);
    return;
  }
  
  eTree = dynamic_cast<TTree*>(eFile->Get("Views"));
  if (!eTree) {
    Log(1, "EdbRun::OpenUpdate", "ERROR! 'Views' tree not found in file: %s", fname);
    SafeDelete(eFile);
    return;
  }
  eViewMerge  = dynamic_cast<TTree*>(eFile->Get("ViewMerge"));
  eViewAlign  = dynamic_cast<TTree*>(eFile->Get("ViewAlign"));
  eFrameAlign = dynamic_cast<TTree*>(eFile->Get("FrameAlign"));
  ePinViews   = dynamic_cast<TTree*>(eFile->Get("PinViews"));
 
  SetView();
  SafeDelete(eHeader);
  eHeader = dynamic_cast<EdbRunHeader*>(eFile->Get("RunHeader"));  
  SafeDelete(ePredictions);
  ePredictions = dynamic_cast<EdbPredictionsBox*>(eFile->Get("Predictions"));
  SafeDelete(eMarks);
  eMarks = dynamic_cast<EdbMarksSet*>(eFile->Get("Marks"));
 
  if(gEDBDEBUGLEVEL>2) Print();
}

OpenUpdate()

void EdbRun::OpenUpdate

(

const char *

fname

)

{
  Log(3,"EdbRun::OpenUpdate","Open an existing file for update %s", fname);
  eFile = TFile::Open(fname,"UPDATE");
  if (!eFile || eFile->IsZombie()) {
    Log(1, "EdbRun::OpenUpdate", "ERROR! Failed to open file: %s", fname);
    SafeDelete(eFile);
    return;
  }
  
  eTree = dynamic_cast<TTree*>(eFile->Get("Views"));
  if (!eTree) {
    Log(1, "EdbRun::OpenUpdate", "ERROR! 'Views' tree not found in file: %s", fname);
    SafeDelete(eFile);
    return;
  }
  SetView();
  
  eViewMerge  = dynamic_cast<TTree*>(eFile->Get("ViewMerge"));
  eViewAlign  = dynamic_cast<TTree*>(eFile->Get("ViewAlign"));
  eFrameAlign = dynamic_cast<TTree*>(eFile->Get("FrameAlign"));
  ePinViews   = dynamic_cast<TTree*>(eFile->Get("PinViews"));
  eViewAlign->SetBranchAddress("alpar",&eVA);
  eViewMerge->SetBranchAddress("alpar",&eVM);
  eFrameAlign->SetBranchAddress("alpar",&eFA);
  ePinViews->SetBranchAddress("pin",&ePVH);
  
  SafeDelete(eHeader);
  eHeader = dynamic_cast<EdbRunHeader*>(eFile->Get("RunHeader"));  
  SafeDelete(ePredictions);
  ePredictions = dynamic_cast<EdbPredictionsBox*>(eFile->Get("Predictions"));
  SafeDelete(eMarks);
  eMarks = dynamic_cast<EdbMarksSet*>(eFile->Get("Marks"));
  
  if(gEDBDEBUGLEVEL>2) Print();
}

Print()

void EdbRun::Print

(

)

const

{
  if(eHeader) eHeader->Print();
 
  int nentr=0;
  if(eTree) nentr = (Int_t)eTree->GetEntries();
  printf("Number of entries: \t %d \n", nentr);
  printf("--------------------------------------------------------------------\n\n");
  //PrintBranchesStatus();
}

PrintBranchesStatus()

void EdbRun::PrintBranchesStatus

(

)

const

{
  // not supported...
 
  EdbViewHeader *header   =  GetEntryHeader( 0 );
  if(header)     printf("header branch exists\n");
  TClonesArray  *clusters =  GetEntryClusters( 0 );
  if(clusters)    printf("clusters branch exists\n");
  TObjArray     *frames   =  GetEntryFrames( 0 );
  if(frames)    printf("frames branch exists\n");
}

PrintLog()

void EdbRun::PrintLog

(

const char *

fname

)

const

{
  char buf[256];
 
  sprintf( buf,"run%4.4d  %s \t%s \t%s",
       GetRunID(),
       eHeader->GetName(),
       eHeader->GetPlate()->GetName(),
       eHeader->GetTitle()     );
 
  printf("**************************************************************************\n");
  printf("\n%s\n", buf);
  printf("**************************************************************************\n");
 
  FILE *fp = fopen( fname,"a" );
  fprintf(fp,"%s", buf);
  fclose(fp);
 
}

Save()

void EdbRun::Save

(

)

{
  if(eHeader)        eHeader->Write("RunHeader");
  if(ePredictions)   ePredictions->Write("Predictions");
  if(eMarks)         eMarks->Write("Marks");
 
  //if(eViewMerge)     eViewMerge->Write();
  //if(eViewAlign)     eViewAlign->Write();
  //if(eFrameAlign)    eViewMerge->Write();
  
  //SaveViews();
  //eFile->Purge();
}

SaveViews()

void EdbRun::SaveViews ( )

inline

{ eTree->AutoSave(); }

SelectOpenMode()

void EdbRun::SelectOpenMode	(	const char *	fname,
		const char *	status = "READ"
	)

{
  if     ( !strcmp(status,"RECREATE") )   Create(fname);
  else if( !strcmp(status,"READ") )       Open(fname);
  else if( !strcmp(status,"UPDATE") )     OpenUpdate(fname);
  else{
    if( !gSystem->AccessPathName(fname, kFileExists) ) Open(fname);
    else                                               Create(fname);
  }
 
  Log(3,"EdbRun::SelectOpenMode","root file version: %d",eFile->GetVersion());
}

SetComment()

void EdbRun::SetComment ( const char *  com )

inline

{ eHeader->SetComment(com);   }

SetMarks()

void EdbRun::SetMarks ( EdbMarksSet *  marks )

inline

{ eMarks = marks; }

SetRunID()

void EdbRun::SetRunID ( int  id )

inline

{ eHeader->SetRunID(id);  }

SetTitle()

void EdbRun::SetTitle ( const char *  tit )

inline

{ eHeader->SetTitle(tit); }

SetView() [1/2]

void EdbRun::SetView

(

)

{
  if(!eView) { 
    Log(2,"EdbRun::SetView","WARNING: *eView=0");    
    eView = new EdbView();
  } 
  else if( !eView->GetClusters() ) {
    Log(1,"EdbRun::SetView","ERROR: eView was deleted!");
    eView = new EdbView();
  }
 
  Log(3,"EdbRun::SetView","Note: EdbRun::SetView");
  if(eView->GetHeader())   eTree->SetBranchAddress("headers",  eView->GetHeaderAddr()   );
  if(eView->GetClusters()) eTree->SetBranchAddress("clusters", eView->GetClustersAddr() );
  if(eView->GetSegments()) eTree->SetBranchAddress("segments", eView->GetSegmentsAddr() );
  if(eView->GetTracks())   eTree->SetBranchAddress("tracks",   eView->GetTracksAddr()   );
  if(eView->GetFrames())   eTree->SetBranchAddress("frames",   eView->GetFramesAddr()   );
}

SetView() [2/2]

void EdbRun::SetView

(

EdbView *

view

)

{
  if(!view) { Log(1,"EdbRun::SetView","ERROR: EdbRun::SetView: *view=0");    return; }
 
  if(eView != view) {
    if(eView) { eView->Clear(); SafeDelete(eView); }
    eView = view;
  }
 
  SetView();
}

TransformDC()

void EdbRun::TransformDC

(

)

{
  if(ePredictions){
    if(eMarks){
      EdbAffine2D *aff = eMarks->Abs2Stage();
      ePredictions->Transform(aff);
      printf("transfrom predictions according to fiducial marks:\n");
      aff->Print();
      SafeDelete(aff);
    }
  }
}

Member Data Documentation

eFA

AlignmentParFrame EdbRun::eFA

private

eFile

TFile* EdbRun::eFile

private

eFrameAlign

TTree* EdbRun::eFrameAlign

private

eHeader

EdbRunHeader* EdbRun::eHeader

private

eMarks

EdbMarksSet* EdbRun::eMarks

ePath

TString EdbRun::ePath

private

ePinViews

TTree* EdbRun::ePinViews

private

ePredictions

EdbPredictionsBox* EdbRun::ePredictions

private

ePVH

EdbViewHeader* EdbRun::ePVH

private

eTree

TTree* EdbRun::eTree

private

eVA

AlignmentParView EdbRun::eVA

private

eVH1

EdbViewHeader* EdbRun::eVH1

private

eVH2

EdbViewHeader* EdbRun::eVH2

private

eView

EdbView* EdbRun::eView

private

eViewAlign

TTree* EdbRun::eViewAlign

private

eViewMerge

TTree* EdbRun::eViewMerge

private

eVM

AlignmentParView EdbRun::eVM

private

---

The documentation for this class was generated from the following files:

• src/libEdb/EdbRun.h
• src/libEdb/EdbRun.cxx