EdbScanClientPav Class Reference

#include <EdbScanClientPav.h>

Inheritance diagram for EdbScanClientPav:

Collaboration diagram for EdbScanClientPav:

Public Member Functions
virtual void	AsyncScanAreaS (int id1, int id2, int id3, int id4, float x1, float x2, float y1, float y2, const char *fname)
virtual void	AsyncScanPreloadAreaS (int id1, int id2, int id3, int id4, float x1, float x2, float y1, float y2, const char *fname, float x1n, float x2n, float y1n, float y2n)
virtual void	AsyncStartScan ()
virtual int	AsyncWaitForScanResult ()
	EdbScanClientPav ()
virtual int	LoadPlate (int BRICK, int PLATE, const char *mapext, int nAttempts=1)
virtual void	Print ()
virtual int	ScanAreas (ScanType st, int id[4], EdbPattern &areas, EdbRun *run, const char *options="")
virtual bool	ScanFromPrediction (int id1, int id2, int id3, int id4, float dx, float dy)
virtual bool	ServerCreatesTarget ()
virtual void	SetClusterThresholds (int TOP, int BOT)
virtual int	SetFragmentSize (int X, int Y)
virtual void	SetOdysseyThresholds (int itop, int ibottom, int size, int TOP, int BOT)
virtual void	SetParameter (const char *Object, const char *Parameter, const char *Value)
void	SetPathLib (const char *lib_)
void	SetPathName (const char *name_)
virtual int	UnloadPlate ()
virtual	~EdbScanClientPav ()
Public Member Functions inherited from EdbScanClientCommon
virtual int	AddRWC_ (EdbRun *run, char *rwcname, int bAddRWD=true, const char *options="")
void	CloseSocket ()
virtual int	ConvertAreas (int id[4], EdbPattern &areas, EdbRun &run, const char *options="")
	EdbScanClientCommon ()
const char *	GetCmd ()
int	GetMaxAttempts ()
int	GetMaxFails ()
const char *	GetMess ()
const char *	GetMess1 ()
float	GetNXView ()
float	GetNYView ()
int	GetPort ()
const char *	GetProcPthServer ()
const char *	GetProcTgtServer ()
const char *	GetRawDirClient ()
const char *	GetRawDirServer ()
const char *	GetServer ()
const char *	GetServerCreatedRunName ()
float	GetXstep ()
float	GetYstep ()
virtual int	InitializeSocket ()
virtual int	ScanPreloadAreaS (int id1, int id2, int id3, int id4, float x1, float x2, float y1, float y2, const char *fname, float x1n, float x2n, float y1n, float y2n)
void	SetCmd (const char *cmd_)
void	SetMaxAttempts (int attempts_)
void	SetMaxFails (int fails_)
void	SetMess (const char *mess_)
void	SetMess1 (const char *mess_)
void	SetNXview (float nxview_)
void	SetNYview (float nyview_)
void	SetPort (int port_)
void	SetProcPthServer (const char *prcpthserver_)
void	SetProcTgtServer (const char *prctgtserver_)
void	SetRawDirClient (const char *rawdirclient_)
void	SetRawDirServer (const char *rawdirserver_)
void	SetServer (const char *server_)
void	SetXstep (float xstep_)
void	SetYstep (float ystep_)
virtual Short_t	ShortBrick (Int_t brick)
virtual	~EdbScanClientCommon ()
Public Member Functions inherited from EdbScanClientBase
	EdbScanClientBase ()
virtual	~EdbScanClientBase ()

Protected Member Functions
void	SetServerTarget ()

Protected Attributes
bool	m_createdTarget
std::vector< uint8 >	m_inbuf
uint32	m_insize
MessageManager	m_mm
MessageReader	m_mr
std::string	m_pathLib
std::string	m_pathName
std::string	m_predPathName
bool	m_scanningStarted
Protected Attributes inherited from EdbScanClientCommon
char	eCMD [CMD_LEN]
int	eMAXFAILS
int	eMAXSCANATTEMPTS
char	eMess [CMD_LEN]
char	eMess1 [CMD_LEN]
float	eNXview
float	eNYview
int	ePORT
TString	eProcPthServer
TString	eProcTgtServer
TString	eRawDirClient
TString	eRawDirServer
TString	eServer
TString	eServerCreatedRunName
TSocket *	eSock
float	eXstep
float	eYstep

Additional Inherited Members
Public Types inherited from EdbScanClientBase
enum	ScanType { stPred , stVolume }

Constructor & Destructor Documentation

EdbScanClientPav()

EdbScanClientPav::EdbScanClientPav ( )

inline

    {
        m_mm.CreateMessage();
    };
  virtual ~EdbScanClientPav(){};

~EdbScanClientPav()

virtual EdbScanClientPav::~EdbScanClientPav ( )

inlinevirtual

{ m_pathLib=lib_; };

Member Function Documentation

AsyncScanAreaS()

void EdbScanClientPav::AsyncScanAreaS ( int  id1, int  id2, int  id3, int  id4, float  x1, float  x2, float  y1, float  y2, const char *  fname  )

virtual

Implements EdbScanClientCommon.

{
    printf("AsyncScanAreaS: not implemented yet, use AsyncScanPreloadAreaS\n");
}

AsyncScanPreloadAreaS()

void EdbScanClientPav::AsyncScanPreloadAreaS ( int  id1, int  id2, int  id3, int  id4, float  x1, float  x2, float  y1, float  y2, const char *  fname, float  x1n, float  x2n, float  y1n, float  y2n  )

virtual

Implements EdbScanClientCommon.

{
    if(!eSock)
        InitializeSocket();
    if(!eSock)
        return;
 
  
    char area[100];
    sprintf(area, "%f %f %f %f", x1, y1, x2, y2); // here goes xmin, ymin, xmax, ymax
    m_mm.AddSetPathParamsNode(m_pathLib.c_str(), m_pathName.c_str(), "area", area, NULL_TRM);
 
    SetServerTarget();
    
    m_mm.AddStartNode(m_pathLib.c_str(), m_pathName.c_str(), "");
    m_mm.FillBuff();
 
  AsyncStartScan();
}

AsyncStartScan()

void EdbScanClientPav::AsyncStartScan ( )

virtual

{
    uint32 len = m_mm.GetBufSize();
 
    int res;
    if(eSock && eSock->IsValid()){
        eSock->SendRaw(&len, sizeof(len));
        eSock->SendRaw(m_mm.GetBuf(), len);
        m_mm.CreateMessage();
 
        int recvBytes = eSock->RecvRaw(&m_insize, sizeof(m_insize));
        if(recvBytes<=0){
            CloseSocket();
            return;
        }
        if(m_inbuf.size()<m_insize)
            m_inbuf.resize(m_insize);
        recvBytes = eSock->RecvRaw(&m_inbuf[0], m_insize);
        if(recvBytes<=0){
            CloseSocket();
            return;
        }
        if(m_insize>0 && m_inbuf.size()){
            printf("msg='%s'\n", &m_inbuf[8]);
            bool res1 = m_mr.Load(&m_inbuf[0], m_insize);
            if(!res1){
                CloseSocket();
                return;
            }
            m_mr.Process();
        }
 
    };
 
    std::string startkey = PAVPROT_NODE_START;
    startkey += "R";
    int startcode;
    const char *startstr = m_mr.GetValueForKey(startkey).c_str();
    res = sscanf(startstr, "%d", &startcode);
    if(!strlen(startstr))
        startcode = PAVPROT_OK;
    else if(res != 1){
        printf("bad server response, stopping\n");
        return;
    };
    switch(startcode){
    case PAVPROT_OK:
        printf("scanning started, waiting it to finish...\n");
        m_scanningStarted = true;
        break;
        
    case PAVPROT_BUSY:
        printf("Scanning not started: server is busy\n");
        m_scanningStarted = false;
        break;
 
    case PAVPROT_ERROR:
    default:
        printf("scanning not started, some error occurred\n");
        m_scanningStarted = false;
        break;
 
    }
}

AsyncWaitForScanResult()

int EdbScanClientPav::AsyncWaitForScanResult ( )

virtual

Implements EdbScanClientCommon.

{
    if(!m_scanningStarted)
        return 0;
    if(eSock) if(eSock->IsValid()){
        int recvBytes = eSock->RecvRaw(&m_insize, sizeof(m_insize));
        if(recvBytes<=0){
            CloseSocket();
            return 0;
        }
        
        if(m_inbuf.size()<m_insize)
            m_inbuf.resize(m_insize);
        recvBytes = eSock->RecvRaw(&m_inbuf[0], m_insize);
        if(recvBytes<=0){
            CloseSocket();
            return 0;
        }
 
        if(m_insize>0 && m_inbuf.size()){
            printf("msg='%s'\n", &m_inbuf[8]);
            bool res = m_mr.Load(&m_inbuf[0], m_insize);
            if(!res){
                CloseSocket();
                return 0;
            }
            m_mr.Process();
        }
    };
    m_scanningStarted = false;
 
    return 1;
}

LoadPlate()

int EdbScanClientPav::LoadPlate ( int  BRICK, int  PLATE, const char *  mapext, int  nAttempts = 1  )

virtual

Implements EdbScanClientCommon.

{
    m_mm.AddMarksNode(BRICK, PLATE, mapext);
    return 1;
}

Print()

virtual void EdbScanClientPav::Print ( )

virtual

Implements EdbScanClientCommon.

ScanAreas()

int EdbScanClientPav::ScanAreas ( EdbScanClientBase::ScanType  st, int  id[4], EdbPattern &  areas, EdbRun *  run, const char *  options = ""  )

virtual

Implements EdbScanClientCommon.

{
  // this function scans the FIRST area from the list. Saving is done by server-side
  // for propper interaction the run  filename should be set in EdbScanProc::SetServerRunName fn
  // returns 1 if scan was successful
 
  int n = areas.N();
  printf("ScanAreas: %d \n",n);
  if(n == 0){
    printf("Nothing to scan.\n");
    return 0;
  }
  int scanned=0, failed=0;
  EdbSegP *s = 0;
  char str[256];
  if(st == stVolume){
    if(n!=1)
      printf("WARNING! Only first prediction is scanned in Volume mode");
    s = areas.GetSegment(0);
    printf("ScanAreas: scan progress: 0 out of 1\n");
    sprintf(str,"%s/raw.%d.%d.%d.%d",eRawDirServer.Data(),ShortBrick(id[0]), id[1], id[2], s->ID());
    while( !ScanPreloadAreaS( id[0], id[1], id[2], s->ID(),
        s->X()-s->SX(), s->X()+s->SX(), s->Y()-s->SY(), s->Y()+s->SY(), 
        str,s->X()-s->SX(), s->X()+s->SX(), s->Y()-s->SY(), s->Y()+s->SY() ) && failed < eMAXFAILS)
      failed++;
    if(failed >= eMAXFAILS)
      printf("EdbScanClient::ScanAreas: ERROR!!! too many failures - stop scanning!\n");
    else
      scanned = 1;
  }else{
    s = areas.GetSegment(0);
    float dx = s->SX(), dy = s->SY();
    for(int i=1; i<n; i++){
      s = areas.GetSegment(1);
      if(s->SX() > dx)
        dx = s->SX();
      if(s->SY() > dy)
        dy = s->SY();
    }
    while( !ScanFromPrediction( id[0], id[1], id[2], id[3], dx, dy) && failed < eMAXFAILS)
      failed++;
    if(failed >= eMAXFAILS)
      printf("EdbScanClient::ScanAreas: ERROR!!! too many failures - stop scanning!\n");
    else
      scanned = n;
  }
  
  return scanned;
}

ScanFromPrediction()

bool EdbScanClientPav::ScanFromPrediction ( int  id1, int  id2, int  id3, int  id4, float  dx, float  dy  )

virtual

                                                                                               {
  if(!eSock)
        InitializeSocket();
    if(!eSock)
        return false;
 
 
    char pars[200];
    sprintf(pars, "%f %f", dx, dy);
    m_mm.AddSetPathParamsNode(m_pathLib.c_str(), m_predPathName.c_str(), "pred_sigma", pars, NULL_TRM);
 
    if(eProcPthServer.Length() != 0)//only if proc path is set, i.e. path to processing directory as seen from scanning srv
      m_mm.AddSetPathParamsNode(m_pathLib.c_str(), m_predPathName.c_str(), "pred_list", eProcPthServer.Data(), NULL_TRM);
 
    sprintf(pars, "%u %u %u %u", id1, id2, id3, id4);
    m_mm.AddSetPathParamsNode(m_pathLib.c_str(), m_predPathName.c_str(), "pred_id", pars, NULL_TRM);
 
    SetServerTarget();
    
    m_mm.AddStartNode(m_pathLib.c_str(), m_predPathName.c_str(), "");
    m_mm.FillBuff();
 
    AsyncStartScan();
  
    if(AsyncWaitForScanResult()==1)
      return true;
    else
      return false;
}

ServerCreatesTarget()

virtual bool EdbScanClientPav::ServerCreatesTarget ( )

inlinevirtual

Implements EdbScanClientCommon.

:

SetClusterThresholds()

void EdbScanClientPav::SetClusterThresholds ( int  TOP, int  BOT  )

virtual

Implements EdbScanClientCommon.

{
  printf("Default values are used from PAVICOM config.\n");
}

SetFragmentSize()

int EdbScanClientPav::SetFragmentSize ( int  X, int  Y  )

virtual

Implements EdbScanClientCommon.

{
    return 1;
}

SetOdysseyThresholds()

void EdbScanClientPav::SetOdysseyThresholds ( int  itop, int  ibottom, int  size, int  TOP, int  BOT  )

virtual

Implements EdbScanClientCommon.

{
    char val[20];
    sprintf(val, "%d %d", BOT, TOP);
  printf("only TOP and BOT thresholds are used in PAVICOM.\n");
    SetParameter("processor", "clz_thres", val);
}

SetParameter()

void EdbScanClientPav::SetParameter ( const char *  Object, const char *  Parameter, const char *  Value  )

virtual

Implements EdbScanClientCommon.

{
  if(!strcmp(Object, "VertigoScanner"))
    return;
    //prevent too many fake sysal stuff
    printf("%s[%s]=%s\n", Object, Parameter, Value);
    m_mm.AddSetModuleParamsNode(Object, Parameter, Value, NULL_TRM);
}

SetPathLib()

void EdbScanClientPav::SetPathLib ( const char *  lib_ )

inline

{ m_pathName=name_; };

SetPathName()

void EdbScanClientPav::SetPathName ( const char *  name_ )

inline

{ return m_createdTarget;};

SetServerTarget()

void EdbScanClientPav::SetServerTarget ( )

protected

                                      {
  std::string path(eProcTgtServer.Data());         //   /opera/ONLINE/b800000/p009/asd.root
  if(eProcPthServer.Length() != 0){
    m_mm.AddSetModuleParamsNode("processor", "clprc.output_file", path.c_str(), NULL_TRM);
  }else{
    m_createdTarget = false;
    std::string spath = eRawDirServer.Data();
    std::string cpath = eRawDirClient.Data();
    char buf[500];
    unsigned int tid=static_cast<unsigned int>(time(0));
    sprintf(buf, "/tracks_%u.raw.root", tid);
    spath += buf;
    cpath += buf;
 
    eServerCreatedRunName = cpath.c_str();
    m_mm.AddSetModuleParamsNode("processor", "clprc.output_file", spath.c_str(), NULL_TRM);
    printf("Server proc dir not set. Please set for speedup.\n");
    return;
  }
 
  m_mm.AddGetModuleParamsNode("processor", "clprc.output_file", NULL_TRM);
  m_mm.FillBuff();
  
  uint32 len = m_mm.GetBufSize();
 
  //int res;
    if(eSock && eSock->IsValid()){
        eSock->SendRaw(&len, sizeof(len));
        eSock->SendRaw(m_mm.GetBuf(), len);
        m_mm.CreateMessage();
 
        int recvBytes = eSock->RecvRaw(&m_insize, sizeof(m_insize));
        if(recvBytes<=0){
            CloseSocket();
            return;
        }
        if(m_inbuf.size()<m_insize)
            m_inbuf.resize(m_insize);
        recvBytes = eSock->RecvRaw(&m_inbuf[0], m_insize);
        if(recvBytes<=0){
            CloseSocket();
            return;
        }
        if(m_insize>0 && m_inbuf.size()){
            printf("msg='%s'\n", &m_inbuf[8]);
            bool res1 = m_mr.Load(&m_inbuf[0], m_insize);
            if(!res1){
                CloseSocket();
                return;
            }
            m_mr.Process();
        }
    };
 
    std::string key = PAVPROT_NODE_GMP;
    key += "R.processor.clprc.output_file";
    if(m_mr.GetValueForKey(key).length() != 0){
        printf("Server creates target file.\n");
      m_createdTarget = true;
    }else{
        m_createdTarget = false;
        printf("Server doesn't create target file. Please update to speedup.\n");
  }
};

UnloadPlate()

int EdbScanClientPav::UnloadPlate ( )

virtual

Implements EdbScanClientCommon.

{
    printf("UnloadPlate: not implemented yet.\n");
    return 1;
}

Member Data Documentation

m_createdTarget

bool EdbScanClientPav::m_createdTarget

protected

m_inbuf

std::vector<uint8> EdbScanClientPav::m_inbuf

protected

m_insize

uint32 EdbScanClientPav::m_insize

protected

m_mm

MessageManager EdbScanClientPav::m_mm

protected

m_mr

MessageReader EdbScanClientPav::m_mr

protected

m_pathLib

std::string EdbScanClientPav::m_pathLib

protected

m_pathName

std::string EdbScanClientPav::m_pathName

protected

m_predPathName

std::string EdbScanClientPav::m_predPathName

protected

m_scanningStarted

bool EdbScanClientPav::m_scanningStarted

protected

---

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

• src/libScan/EdbScanClientPav.h
• src/libScan/EdbScanClientPav.cxx