EdbGA Class Reference

#include <EdbGA.h>

Inheritance diagram for EdbGA:

Collaboration diagram for EdbGA:

Public Member Functions
void	CheckViewGrains (const char *options="")
void	CheckViewGrains (int vid, const char *options="")
	EdbGA ()
	EdbGA (char *fname, float bx, float by, float bz)
void	GetClustPFile (const char *file)
TTree *	GetTree (void)
void	GrainStat (TClonesArray *clusters, float &x0, float &y0, float &z0)
int	GrainStat2 (TClonesArray *clusters, float &x0, float &y0, float &z0, float &vol, float &amin, float &amax, float &zmin, float &zmax, int &fmin, int &fmax)
void	InitTree (const char *file="grain_chains.root")
int	MakeGrainsTree (TClonesArray *clust, TIndexCell &chains, const char *options="")
void	SelectGrains (const char *selection, const char *outfile="grains_chains_selection.root")
void	SelectGrains (TCut c1, const char *outfile="grains_chains_selection.root")
void	SetBin (float bx, float by, float bz)
void	SetRun (char *fname)
void	VerticalChains (TClonesArray *clusters, TIndexCell &chains)
void	VerticalChainsA (TClonesArray *clusters)
virtual	~EdbGA ()

Private Attributes
Float_t	eBinX
Float_t	eBinY
Float_t	eBinZ
TClonesArray *	eClusters
TTree *	eGrains
TFile *	eGrainsFile
EdbRun *	eRun
Int_t	eVid

Constructor & Destructor Documentation

EdbGA() [1/2]

EdbGA::EdbGA ( )

inline

{eRun=0;}

EdbGA() [2/2]

EdbGA::EdbGA	(	char *	fname,
		float	bx,
		float	by,
		float	bz
	)

~EdbGA()

EdbGA::~EdbGA ( )

virtual

---

{
  if(eGrainsFile) { 
    eGrainsFile->Write(); 
    eGrainsFile->Purge(); 
    eGrainsFile->Close(); 
  }
  if(eRun)   delete eRun;  
}

Member Function Documentation

CheckViewGrains() [1/2]

void EdbGA::CheckViewGrains

(

const char *

options = ""

)

---

{
  int nview = eRun->GetEntries();
  for(int i=0; i< nview ; i++)  CheckViewGrains(i,options);
}

CheckViewGrains() [2/2]

void EdbGA::CheckViewGrains	(	int	vid,
		const char *	options = ""
	)

---

{
  eVid = vid;
  TClonesArray *clusters=0;
 
  clusters = eRun->GetEntryClusters(vid);
 
  printf("%d clusters are read for view %d \n", clusters->GetEntriesFast(), vid );
 
  TIndexCell chains;
  VerticalChains(clusters,chains);
  MakeGrainsTree(clusters,chains,options);
}

GetClustPFile()

void EdbGA::GetClustPFile

(

const char *

file

)

---

{
  TFile *fcl = new TFile(file);
  TTree *clust = (TTree *)fcl->Get("clust");
  EdbClustP *clp = 0;
  clust->SetBranchAddress("cl",&clp);
 
  int nentr = (int)(clust->GetEntries());
  TClonesArray *clarr = new TClonesArray("EdbCluster");
 
  int ncl =0;
  for(int i=0; i<nentr; i++) {
    clust->GetEntry(i);
    //if( clp->GetZ()>-50.) continue;
    //if( clp->Xp()<500.) continue;
    //if( clp->Xp()>600.) continue;
    //if( clp->Yp()<500.) continue;
    //if( clp->Yp()>600.) continue;
 
    new((*clarr)[ncl])  
      EdbCluster( clp->Xcg(),clp->Ycg(),clp->Z(),
          clp->GetArea(), clp->Peak(), clp->GetFrame(), 0);
    ncl++;
  }
  fcl->Close();
  delete fcl;
  printf("%d clusters are readed from %s\n",ncl,file);
 
 
  SetBin(4,4,1);
  TIndexCell chains;
  printf("chains\n");
  VerticalChains(clarr,chains);
//    for(int i=0; i<10; i++) {
//      printf("chainsA\n");
//      VerticalChainsA(clarr);
//    }
  printf("\n tree: \n\n");
  InitTree("grains_tree.root");
  MakeGrainsTree(clarr,chains);
  eGrainsFile->Close();  
}

GetTree()

TTree* EdbGA::GetTree ( void  )

inline

{return eGrains;}

GrainStat()

void EdbGA::GrainStat	(	TClonesArray *	clusters,
		float &	x0,
		float &	y0,
		float &	z0
	)

---

  {
  double xs=0,ys=0,zs=0; 
  EdbCluster *cl=0;
  int ncl = clusters->GetEntriesFast();
  for( int i=0; i<ncl; i++ ) {
    cl = (EdbCluster *)clusters->At(i);
    xs += cl->X();
    ys += cl->Y();
    zs += cl->Z();
  }
  x0 = xs/ncl;
  y0 = ys/ncl;
  z0 = zs/ncl;
  }

GrainStat2()

int EdbGA::GrainStat2	(	TClonesArray *	clusters,
		float &	x0,
		float &	y0,
		float &	z0,
		float &	vol,
		float &	amin,
		float &	amax,
		float &	zmin,
		float &	zmax,
		int &	fmin,
		int &	fmax
	)

---

  {
  float x,y,z,area,xs=0,ys=0,zs=0,areasum=0; 
  int frame; 
  EdbCluster *cl=0;
  amin  = 10000000;
  amax  =  0;
  zmin  =  1.e30; 
  zmax  = -1.e30;
  fmin  = 10000000; 
  fmax  =  0;
 
  int ncl = clusters->GetEntriesFast();
  for( int i=0; i<ncl; i++ ) 
  {
    cl = (EdbCluster *) clusters->At(i);
    x = cl->X();  
    y = cl->Y(); 
      z = cl->Z(); 
      frame = cl->GetFrame() ; 
      area  = cl->GetArea()  ;
    if(area < amin) amin = area ;
    if(area > amax) amax = area ;
    if(frame   < fmin   ) { fmin = frame ; zmax = z ;}
    if(frame   > fmax   ) { fmax = frame ; zmin = z ;}
  /*    xs += x*area;
    ys += y*area;
    zs += z*area;
  */    xs += x;
      ys += y;
      zs += z;
    areasum += area;
  }
  /*  x0 = xs/areasum;
  y0 = ys/areasum;
  z0 = zs/areasum;
  */  x0 = xs/ncl;
  y0 = ys/ncl;
  z0 = zs/ncl;
 
  float zlen = zmax - zmin;
  if(zlen && ncl>1) vol = areasum*zlen/(ncl-1) ;    // should be (areasum/ncl) * (zlen*ncl/(ncl-1))
  else vol = -999;
 
  return 0;
}

InitTree()

void EdbGA::InitTree

(

const char *

file = "grain_chains.root"

)

---

{
  eGrainsFile= new TFile(file,"RECREATE");
  eGrains= new TTree("grains","grains");
 
  Int_t ncl=0,fmin,fmax;
  eClusters=new TClonesArray("EdbCluster");
  Float_t x0,y0,z0,vol,amin,amax, zmin, zmax; 
 
  eGrains->Branch("vid",&eVid,"eVid/I");
  eGrains->Branch("ncl",&ncl,"ncl/I");
  eGrains->Branch("clusters",&eClusters);
  eGrains->Branch("x0",&x0,"x0/F");
  eGrains->Branch("y0",&y0,"y0/F");
  eGrains->Branch("z0",&z0,"z0/F");
  eGrains->Branch("vol",&vol,"vol/F");
  eGrains->Branch("amin",&amin,"amin/F");
  eGrains->Branch("amax",&amax,"amax/F");
  eGrains->Branch("zmin",&zmin,"zmin/F");
  eGrains->Branch("zmax",&zmax,"zmax/F");
  eGrains->Branch("fmin",&fmin,"fmin/I");
  eGrains->Branch("fmax",&fmax,"fmax/I");
}

MakeGrainsTree()

int EdbGA::MakeGrainsTree	(	TClonesArray *	clust,
		TIndexCell &	chains,
		const char *	option = ""
	)

---

{
 
  // process the options
  int min_ncl=1;  // minimum number of clusters of each grains 
  if (! sscanf(option,"MIN_NCL") ) sscanf(option,"MIN_NCL=%d",&min_ncl);
 
  // set branch addresses
  Int_t ncl=0,fmin, fmax;
  Float_t x0,y0,z0,vol,amin,amax, zmin, zmax;
  eGrains->SetBranchAddress("vid",&eVid);
  eGrains->SetBranchAddress("ncl",&ncl);
  eGrains->SetBranchAddress("clusters",&eClusters);
  eGrains->SetBranchAddress("x0",&x0);
  eGrains->SetBranchAddress("y0",&y0);
  eGrains->SetBranchAddress("z0",&z0);
  eGrains->SetBranchAddress("vol",&vol);
  eGrains->SetBranchAddress("amin",&amin);
  eGrains->SetBranchAddress("amax",&amax);
  eGrains->SetBranchAddress("zmin",&zmin);
  eGrains->SetBranchAddress("zmax",&zmax);
  eGrains->SetBranchAddress("fmin",&fmin);
  eGrains->SetBranchAddress("fmax",&fmax);
 
  int ngr=0;
  int entry=0;
 
  TIndexCell *cx;
  TIndexCell *cy;
  TIndexCell *cz;
 
  float zlvl;
  EdbCluster *cl;
 
  int nix,niy,niz,nie;
 
  nix = chains.GetEntriesFast();
  for(int ix=0; ix<nix; ix++)  {
    cx = chains.At(ix);
    niy = cx->GetEntriesFast();
    for(int iy=0; iy<niy; iy++)   {
      cy = cx->At(iy);
      zlvl = -9999999.;
      niz = cy->GetEntriesFast();
      for(int iz=0; iz<niz; iz++) {
        cz = cy->At(iz);
        nie = cz->GetEntriesFast();
        for(int ie=0; ie<nie; ie++) {
          entry = cz->At(ie)->Value();
          cl = (EdbCluster *)clust->UncheckedAt(entry);
 
          if( cl->Z()-zlvl > 2.*eBinZ ) {
            if( ncl>0 ) {
              if(ncl>=min_ncl) {
                  //GrainStat(eClusters,x0,y0,z0);
                GrainStat2(eClusters,x0,y0,z0,vol,amin,amax, zmin, zmax, fmin, fmax);
                  eGrains->Fill();
                  ngr++;
              }
                eClusters->Clear();
                ncl=0;
                }
          }
              new((*eClusters)[ncl])  EdbCluster( *cl );
              ncl++;
              zlvl=cl->Z();
            }
      }
 
      if( ncl>0 ) {
          if(ncl>=min_ncl) {
              //GrainStat(eClusters,x0,y0,z0);
            GrainStat2(eClusters,x0,y0,z0,vol,amin,amax, zmin, zmax, fmin, fmax);
              eGrains->Fill();
              ngr++;
        }
        eClusters->Clear();
        ncl=0;
      }
    }
  }
 
  eGrains->Write();
  printf("%d grains are selected\n",ngr);
 
  return ngr;
  }

SelectGrains() [1/2]

void EdbGA::SelectGrains	(	const char *	selection,
		const char *	outfile = "grains_chains_selection.root"
	)

---

{
// save only the selected grains
 
   // set branch addresses
   Int_t ncl,fmin, fmax;
   Float_t x0,y0,z0,vol,amin,amax, zmin, zmax;
   eGrains->SetBranchAddress("vid",&eVid);
   eGrains->SetBranchAddress("ncl",&ncl);
   eGrains->SetBranchAddress("clusters",&eClusters);
   eGrains->SetBranchAddress("x0",&x0);
   eGrains->SetBranchAddress("y0",&y0);
   eGrains->SetBranchAddress("z0",&z0);
   eGrains->SetBranchAddress("vol",&vol);
   eGrains->SetBranchAddress("amin",&amin);
   eGrains->SetBranchAddress("amax",&amax);
   eGrains->SetBranchAddress("zmin",&zmin);
   eGrains->SetBranchAddress("zmax",&zmax);
   eGrains->SetBranchAddress("fmin",&fmin);
   eGrains->SetBranchAddress("fmax",&fmax);
 
   //select the event list
   printf("Total: %d grains\n", (int)eGrains->GetEntries());
   eGrains->Draw(">>lst",selection);
   TEventList* lst = (TEventList*) gDirectory->Get("lst");
 
   // create a new tree
   TFile* nfile = new TFile(outfile,"recreate");
   TTree* tree2 = (TTree*) eGrains->CloneTree(0);
   tree2->CopyAddresses(eGrains);
 
   int nentries = lst->GetN(); printf("Select %d grains",nentries);  printf(" with \"%s\"\n", selection);
   printf("Create the new tree...     ");
   for(int i=0;i<nentries;i++)
   {
      eGrains->GetEntry(lst->GetEntry(i));
      tree2->Fill();
      if((i%5000)==0) printf("\b\b\b\b%3d%%",(int)((double)i/double(nentries)*100.)) ;
   }
   printf("\b\b\b\b100%%\n");
   tree2->Write("grains",TObject::kOverwrite);
   nfile->Close();
}

SelectGrains() [2/2]

void EdbGA::SelectGrains	(	TCut	c1,
		const char *	outfile = "grains_chains_selection.root"
	)

---

{
  SelectGrains(c1.GetTitle(), outfile);
}

SetBin()

void EdbGA::SetBin ( float  bx, float  by, float  bz  )

inline

    { eBinX=bx; eBinY=by; eBinZ=bz; } 

SetRun()

void EdbGA::SetRun ( char *  fname )

inline

    { if(eRun) delete eRun; 
      eRun=new EdbRun(fname); }

VerticalChains()

void EdbGA::VerticalChains	(	TClonesArray *	clusters,
		TIndexCell &	chains
	)

---

{
  //chains: "x:y:z:entry"
 
  Long_t v[5];
  float xb=eBinX, yb=eBinY, zb=eBinZ;    // bins
 
  EdbCluster *cl;
 
  int ncl = clusters->GetEntriesFast();
  for( int i=0; i<ncl; i++ ) {
    cl = (EdbCluster*)(clusters->UncheckedAt(i));
    v[0] = (Long_t)(cl->X()/xb);
    v[1] = (Long_t)(cl->Y()/yb);
    v[2] = (Long_t)(cl->Z()/zb);
    v[3] = (Long_t)i;
    chains.Add(4,v);
  }
 
  chains.Sort();
  //chains.PrintStat();
  //chains.PrintPopulation(3);
}

VerticalChainsA()

void EdbGA::VerticalChainsA

(

TClonesArray *

clusters

)

---

{
  float eDX = 1301, eDY=1025;
  eBinX=4; eBinY=4;
  const int nx = (int)(eDX/eBinX);
  const int ny = (int)(eDY/eBinY);
  const int nz = 50; 
 
  int *v = new int[nx*nx*ny];
 
  int ix,iy,iz,iv;
 
  EdbCluster *cl;
 
  for(iz=0; iz<nz; iz++)
    for(iy=0; iy<ny; iy++)
      for(ix=0; ix<nx; ix++) {
    iv = ix + nx*iy + nx*ny*iz;
    v[iv] = -1;
      }
  
  int ncl = clusters->GetEntriesFast();
  for( int i=0; i<ncl; i++ ) {
    cl = (EdbCluster*)(clusters->UncheckedAt(i));
    ix = (int)(cl->X()/eBinX);
    iy = (int)(cl->Y()/eBinY);
    iz = (int)(cl->GetFrame());
 
    iv = ix + nx*iy + nx*ny*iz;
    v[iv] = i;
  }
 
  delete[] v;
}

Member Data Documentation

eBinX

Float_t EdbGA::eBinX

private

eBinY

Float_t EdbGA::eBinY

private

eBinZ

Float_t EdbGA::eBinZ

private

eClusters

TClonesArray* EdbGA::eClusters

private

eGrains

TTree* EdbGA::eGrains

private

eGrainsFile

TFile* EdbGA::eGrainsFile

private

eRun

EdbRun* EdbGA::eRun

private

eVid

Int_t EdbGA::eVid

private

---

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

• src/libEGA/EdbGA.h
• src/libEGA/EdbGA.cxx