EdbFeedback Class Reference

#include <TOracleServerE2WFB.h>

Inheritance diagram for EdbFeedback:

Collaboration diagram for EdbFeedback:

Public Member Functions
const char *	Darkness (int drk)
const char *	DecayFlag (int flag)
	EdbFeedback ()
	array of tracks More...
int	InitDB (const char *conn, const char *user, const char *pwd)
int	LoadFBintoDB ()
const char *	Ofb (int ofb)
const char *	PartType (int parttype)
void	Print ()
void	Print (fbsegment *s)
void	Print (fbtrack *t)
void	Print (fbvertex *v)
void	PrintFB ()
int	ReadFBFile (const char *file)
fbsegment *	ReadSegment (FILE *f)
fbtrack *	ReadTrack (const char *str)
fbvertex *	ReadVertex (const char *str)
const char *	SegmentRecMode (int mode)
const char *	SegmentType (int type)
	~EdbFeedback ()

Public Attributes
ULong64_t	eBrick
TOracleServerE2WFB *	eDB
Int_t	eERROR
ULong64_t	eEvent
ULong64_t	eEventBrick
ULong64_t	eIdMachine
ULong64_t	eIdProgramsettings
ULong64_t	eIdRequester
int	eNtr
int	eNtrLim
int	eNvtx
int	eNvtxLim
ULong64_t	eProcOp
ULong64_t	eRecID
fbtrack **	eT
	array of vertices More...
fbvertex **	eV

Constructor & Destructor Documentation

EdbFeedback()

EdbFeedback::EdbFeedback

(

)

array of tracks

{
  eDB=0;
  eEvent=0;
  eEventBrick=0;
  eProcOp=0;
  eNvtx=0;
  eNvtxLim=1000;
  eNtr=0;
  eNtrLim=5000;
  eV=0;
  eIdMachine=0;
  eIdProgramsettings=0;
  eIdRequester=0;
  eERROR=0;
}

~EdbFeedback()

EdbFeedback::~EdbFeedback ( )

inline

{}

Member Function Documentation

Darkness()

const char * EdbFeedback::Darkness

(

int

drk

)

{
  if (drk==0) return  "'MIP'";
  if (drk==1) return  "'BLACK'";
  if (drk==2) return  "'GRAY'";
  return  "null";
}

DecayFlag()

const char * EdbFeedback::DecayFlag

(

int

flag

)

{
  if (flag==1) return "'PRIMARY'";
  if (flag==2) return "'E+E-'";
  if (flag==3) return "'LOWP'";
  if (flag==4) return "'SF TODO'";
  if (flag==5) return "'SF DONE'";
  return  "null";
}

InitDB()

int EdbFeedback::InitDB	(	const char *	conn,
		const char *	user,
		const char *	pwd
	)

{
  eDB = new TOracleServerE2WFB( conn, user, pwd );
  if(!eDB) return 0;
  return 1;
}

LoadFBintoDB()

int EdbFeedback::LoadFBintoDB

(

)

{
  if(eNtr<1)  return 0; 
  if(!eDB)    return 0;
 
  eProcOp = eDB->AddProcessOperationBrick(
      eIdMachine,      // id_machine
  eIdProgramsettings,  // id_programsettings
  eIdRequester,        // id_requester
  eEventBrick,         // id_eventbrick
  0 ,                  // id_parent_operation
  eDB->Timestamp(),    // starttime
  "Feedback");         // notes
 
  eRecID  = eDB->AddFeedbackReconstruction( eEventBrick,eProcOp );
  
  Log(2,"EdbFeedback::LoadFBintoDB","%d tracks to be added to RecID %d",eNtr, eRecID);
 
  for( int iv=0; iv<eNvtxLim; iv++ ) {
    fbvertex *v = eV[iv];
    if(v) { 
      const char *vprim  = v->isprim? "'Y'" : "'N'";
      const char *vcharm = v->ischarm? "'Y'" : "'N'";
      const char *vtau   = v->istau? "'Y'" : "'N'";
      const char *vout   = v->ofb? "'Y'" : "'N'";
      eDB->AddFeedbackVertex(eEventBrick, eRecID, v->idvtx, v->x, v->y, v->z, vprim,vcharm,vtau,vout);
    }
  }
  
  for(int it=0; it<eNtr; it++ ) {
    fbtrack *t = eT[it];
    if(!t) { 
      Log(1,"EdbFeedback::LoadFBintoDB","ERROR: track %d is missing!", it);
      eERROR=1;
      return 0; 
    }
 
    const char *tman = t->isman? "'Y'" : "'N'";
    const char *tparticle = PartType(t->type);
    const char *tscanback = t->scanback? "'Y'" : "'N'";
    const char *tdarkness = Darkness(t->darkness);
    const char *tofb = Ofb(t->ofb);
    const char *tdecaysearch = DecayFlag(t->flag);
 
    eDB->AddFeedbackTrack( eEventBrick, eRecID,t->id_track, t->id_upvtx, t->id_downvtx,
                           t->x, t->y, t->z, t->sx, t->sy,
                           tman, tparticle, tscanback, tdarkness,
                           t->upip, t->downip, t->p, t->pmin,  t->pmax,
                           tofb,
                           t->lastplate,
                           t->rslopet , t->rslopel, t->rmsslopet , t->rmsslopel,
                           t->kinkplatedown , t->kinkplateup,
                           tdecaysearch,
                           eEvent
                         );
 
    for(int is=0; is<t->nseg; is++ ) {
      fbsegment *s = t->segments[is];
      if(!s) { 
        Log(1,"EdbFeedback::LoadFBintoDB","ERROR: segment %d of track %d is missing!", is, it);
        eERROR=1;
        return 0; 
      }
      if(s->id_plate!=44)
        eDB->AddFeedbackSegment( eEventBrick, eRecID, 
                                 s->id_plate, t->id_track, 
                                 SegmentType(s->type),
                                 s->x, s->y, s->z, s->sx, s->sy,
                                 s->grains, 
                                 SegmentRecMode(s->irec)
                               );
    }
  }
 
  eDB->CloseFeedbackDataset( eProcOp, eDB->Timestamp() );
 
  return 1;
}

Ofb()

const char * EdbFeedback::Ofb

(

int

ofb

)

{
  if (ofb==0) return  "'  '";
  if (ofb==1) return  "'PASSING_THROUGH'";
  if (ofb==2) return  "'EDGE_OUT'";
  return  "null";
}

PartType()

const char * EdbFeedback::PartType

(

int

parttype

)

{
  if (partype==1) return  "'MUON'";
  if (partype==2) return  "'CHARM'";
  if (partype==3) return  "'ELECTRON'";
  if (partype==4) return  "'E-PAIR'";
  if (partype==5) return  "'TAU'";
  return  "null";
}

Print() [1/4]

void EdbFeedback::Print

(

)

{
  printf("\n--------------------------------------------------------\n");
  printf("EdbFeedback: \n\
  \t eEventBrick=%lld \n\
      \t eEvent=%lld \n\
      \t eProcOp=%lld \n\
      \t eNvtx=%d  \n\
      \t eIdMachine=%lld  \n\
      \t eIdProgramsettings=%lld  \n\
      \t eIdRequester=%lld \n", 
  eEventBrick,eEvent,eProcOp,eNvtx,eIdMachine,eIdProgramsettings,eIdRequester);
  if(eDB) eDB->Print();
  printf("--------------------------------------------------------\n\n");
}

Print() [2/4]

void EdbFeedback::Print

(

fbsegment *

s

)

{
  if(s) printf("%d %f %f %f %f %f %d %d %d\n",
  s->id_plate, s->x , s->y , s->z , s->sx , s->sy,
  s->type , s->irec , s->grains
              );
}

Print() [3/4]

void EdbFeedback::Print

(

fbtrack *

t

)

{
  if(t) printf("%d %d %d %f %f %f %f %f %f %f %f %f %f %d %d %d %d %d %d %d %f %f %f %f %d %d %d\n",
  t->id_track, t->id_upvtx, t->id_downvtx, 
  t->x, t->y, t->z, t->sx, t->sy,
  t->upip, t->downip, 
  t->p, t->pmin,  t->pmax, 
  t->isman, t->type , t->scanback , t->darkness , t->ofb , t->lastplate,
  t->nseg , t->rmsslopet , t->rmsslopel , t->rslopet , t->rslopel , 
  t->kinkplatedown , t->kinkplateup , t->flag
              );
}

Print() [4/4]

void EdbFeedback::Print

(

fbvertex *

v

)

{
  if(v) printf("%d %f %f %f %d %d %d %d %d %d\n",
  v->idvtx, v->x, v->y, v->z,
  v->isprim, v->ischarm, v->istau, v->nup, v->ndown, v->ofb
              );
}

PrintFB()

void EdbFeedback::PrintFB

(

)

{
  for( int iv=0; iv<eNvtxLim; iv++ ) {
    fbvertex *v = eV[iv];
    if(v)    Print(v);
  }
 
  for(int it=0; it<eNtrLim; it++ ) {
    fbtrack *t = eT[it];
    if(t) {
      Print(t);
      for(int is=0; is<t->nseg; is++ ) {
        fbsegment *s = t->segments[is];
        if(s) Print(s);
      }
    }
  }
}

ReadFBFile()

int EdbFeedback::ReadFBFile

(

const char *

file

)

{
  FILE *f = fopen(file,"r");  if(!f) {
    Log(1,"EdbFeedback::ReadFBFile","ERROR! open file %s", file); 
    eERROR=1;
    return 0;
  }
  Log(2,"EdbFeedback::ReadFBFile","%s", file);
   
  eNvtx=0;
  eV = new fbvertex*[eNvtxLim]; for(int i=0; i<eNvtxLim; i++) eV[i]=0;
  
  eNtr=0;
  eT = new fbtrack*[eNtrLim]; for(int i=0; i<eNtrLim; i++) eT[i]=0;
 
  char str[1024];
  while(  fgets( str, sizeof(str), f) )
  {
    if( fbvertex *v = ReadVertex(str) )
    {
      if( v->idvtx<0 && v->idvtx>=eNvtxLim )
      {
        Log(1,"EdbFeedback::ReadFBFile","ERROR: vertex id %d is out of range (0-%d)!",v->idvtx,eNvtxLim); 
        eERROR=1;
        break;
      }
      if( eV[v->idvtx]!=0 ) 
      {
        Log(1,"EdbFeedback::ReadFBFile","ERROR: vertex id (%d) is duplicated!",v->idvtx);
        eERROR=1;
        break;
      }
 
      eV[v->idvtx] = v;
      eNvtx++;
    }
    else if( fbtrack *t = ReadTrack(str) )
    {
      if( eNtr>=eNtrLim )
      {
        Log(1,"EdbFeedback::ReadFBFile","ERROR: tracks out of limit %d!",eNtrLim);
        eERROR=1;
        break;
      }
 
      if( t->nseg > 0) {
        t->segments = new fbsegment*[t->nseg];
        for(int iseg=0; iseg < t->nseg; iseg++) {
          t->segments[iseg] = ReadSegment(f);
          if( !(t->segments[iseg]) ) Log(1,"EdbFeedback::ReadFBFile","ERROR: read segment (%d) of track %d!",iseg,t->id_track);
        }
      }
      eT[eNtr++]=t;
    }
    else 
    {
      Log(1,"EdbFeedback::ReadFBFile","ERROR! bad line: %s", str); 
      eERROR=1;
    }
  }
  Log(2,"EdbFeedback::ReadFBFile","%d vertices and %d tracks read from %s", eNvtx,eNtr,file );
  return eNvtx;
}

ReadSegment()

fbsegment * EdbFeedback::ReadSegment

(

FILE *

f

)

{
  char str[512];
  fgets( str, sizeof(str), f);
  fbsegment *s = new fbsegment();
  if( 9 != sscanf(str,"%d %f %f %f %f %f %d %d %d",
      &s->id_plate, &s->x , &s->y , &s->z , &s->sx , &s->sy , 
      &s->type , &s->irec , &s->grains
                  ))
  {
    Log(1,"EdbFeedback::ReadSegment","ERROR! bad seg line: %s", str); 
    eERROR=1;
    delete s;
    return 0; 
  }
  return s;
}

ReadTrack()

fbtrack * EdbFeedback::ReadTrack

(

const char *

str

)

{
  fbtrack *t = new fbtrack();
  if( 27 != sscanf(str,"%d %d %d %f %f %f %f %f %f %f %f %f %f %d %d %d %d %d %d %d %f %f %f %f %d %d %d",
      &t->id_track, &t->id_upvtx, &t->id_downvtx, 
      &t->x, &t->y, &t->z, &t->sx, &t->sy,
      &t->upip, &t->downip, 
      &t->p, &t->pmin,  &t->pmax, 
      &t->isman, &t->type , &t->scanback , &t->darkness , &t->ofb , &t->lastplate,
      &t->nseg , &t->rmsslopet , &t->rmsslopel , &t->rslopet , &t->rslopel , 
      &t->kinkplatedown , &t->kinkplateup , &t->flag
                  ))
  {
    Log(1,"EdbFeedback::ReadTrack","ERROR! bad trk line: %s", str); 
    eERROR=1;
    SafeDelete(t);
    return 0; 
  }
  return t;
}

ReadVertex()

fbvertex * EdbFeedback::ReadVertex

(

const char *

str

)

{
  fbvertex *v = new fbvertex();
  int npar=sscanf(str,"%d %f %f %f %d %d %d %d %d %d",
                  &v->idvtx, &v->x, &v->y, &v->z,
                  &v->isprim, &v->ischarm, &v->istau, &v->nup, &v->ndown, &v->ofb
                 );
  if(10 != npar)  SafeDelete(v);
  return v;
}

SegmentRecMode()

const char * EdbFeedback::SegmentRecMode

(

int

mode

)

{
  if (mode==0) return "'A'";
  if (mode==1) return "'S'";
  if (mode==2) return "'M'";
  return  "null";
}

SegmentType()

const char * EdbFeedback::SegmentType

(

int

type

)

{
  if (type==0) return "'B'";
  if (type==1) return "'U'";
  if (type==2) return "'D'";
  return  "null";
}

Member Data Documentation

eBrick

ULong64_t EdbFeedback::eBrick

eDB

TOracleServerE2WFB* EdbFeedback::eDB

eERROR

Int_t EdbFeedback::eERROR

eEvent

ULong64_t EdbFeedback::eEvent

eEventBrick

ULong64_t EdbFeedback::eEventBrick

eIdMachine

ULong64_t EdbFeedback::eIdMachine

eIdProgramsettings

ULong64_t EdbFeedback::eIdProgramsettings

eIdRequester

ULong64_t EdbFeedback::eIdRequester

eNtr

int EdbFeedback::eNtr

eNtrLim

int EdbFeedback::eNtrLim

eNvtx

int EdbFeedback::eNvtx

eNvtxLim

int EdbFeedback::eNvtxLim

eProcOp

ULong64_t EdbFeedback::eProcOp

eRecID

ULong64_t EdbFeedback::eRecID

eT

fbtrack** EdbFeedback::eT

array of vertices

eV

fbvertex** EdbFeedback::eV

---

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

• src/libEOracle/TOracleServerE2WFB.h
• src/libEOracle/TOracleServerE2WFB.cxx