EdbScan2DB Class Reference

#include <TOracleServerE2WX.h>

Inheritance diagram for EdbScan2DB:

Collaboration diagram for EdbScan2DB:

Public Member Functions
void	AddBrick (EdbScanProc &sproc)
ULong64_t	AddHeaderOperation (const char *note)
void	DumpListOfHeaderOperations ()
	EdbScan2DB ()
int	InitDB (const char *conn, const char *user, const char *pwd)
void	LoadCalibration (EdbScanProc &sproc, EdbID edbid)
ULong64_t	LoadCalibrationZone (EdbScanProc &sproc, EdbID edbid, ULong64_t operation)
void	LoadPrediction (EdbScanProc &sproc, EdbID edbid)
void	LoadSBData (EdbScanProc &sproc, EdbID id, ULong64_t operation)
void	LoadSBDataOld (EdbScanProc &sproc, EdbID id, ULong64_t operation)
void	LoadVolume (EdbScanProc &sproc, EdbID edbid, EdbID idstop)
ULong64_t	LoadZone (EdbSegP &s, int plate, ULong64_t operation, ULong64_t series, const char *cmt)
void	Print ()
	~EdbScan2DB ()

Public Attributes
ULong64_t	eBrick
ULong64_t	eCalibrationHeaderOperation
ULong64_t	eCalibrationProgramsettings
TOracleServerE2WX *	eDB
Int_t	eERROR
ULong64_t	eEvent
ULong64_t	eEventBrick
ULong64_t	eFeedbackProgramsettings
ULong64_t	eHeaderProgramsettings
TString	eID_SET
ULong64_t	eIdMachine
Int_t	eIDPATH
ULong64_t	eIdRequester
Int_t	eIsBlackCS
ULong64_t	ePredictionHeaderOperation
ULong64_t	ePredictionProgramsettings
ULong64_t	eVolumeHeaderOperation
ULong64_t	eVolumeProgramsettings
Bool_t	eWriteRawCalibrationData
Int_t	eX_marks

Constructor & Destructor Documentation

EdbScan2DB()

EdbScan2DB::EdbScan2DB

(

)

{
  eX_marks=0;
  eWriteRawCalibrationData=0;
  eDB=0;
  eBrick=0;
  eEvent=0;
  eEventBrick=0;
  eIsBlackCS=0;
  eIDPATH=-1;
  eIdMachine=0;
  eIdRequester=0;
  eHeaderProgramsettings=0;
  eCalibrationProgramsettings=0;
  ePredictionProgramsettings=0;
  eVolumeProgramsettings=0;
  eFeedbackProgramsettings=0;
  ePredictionHeaderOperation=0;
  eCalibrationHeaderOperation=0;
  eVolumeHeaderOperation=0;
  eERROR=0;
}

~EdbScan2DB()

EdbScan2DB::~EdbScan2DB ( )

inline

{}

Member Function Documentation

AddBrick()

void EdbScan2DB::AddBrick

(

EdbScanProc &

sproc

)

{
  Log(2,"EdbScan2DB::AddBrick","%d",eEventBrick);
  if(eDB->IfEventBrick( eEventBrick, eID_SET.Data()))
  {
    Log(2,"EdbScan2DB::AddBrick","%d is already in DB, do nothing",eEventBrick);
    if(!eDB->TestLoad()) return;
  }
 
  //========== Loading X ray mark sets in global RS to get ZEROX,ZEROY ===========//
  EdbMarksSet msXG;
  sproc.ReadMarksSet(msXG,eBrick,"map.XG",'_','S');
  float ZEROX = msXG.eXmin;
  float ZEROY = msXG.eYmin;
 
  //========== Loading Optical ray mark sets in local (and corrected) RS to get brick dimension ==========//
  EdbMarksSet msOL;
  if (eX_marks) sproc.ReadMarksSet(msOL,eBrick,"map.LL",'_','L');
  else sproc.ReadMarksSet(msOL,eBrick,"map.OL",'_','S');
  float MINX = msOL.eXmin + ZEROX;
  float MAXX = msOL.eXmax + ZEROX;
  float MINY = msOL.eYmin + ZEROY;
  float MAXY = msOL.eYmax + ZEROY;
  float MINZ = -72800.;
  float MAXZ = 0.;
  float ZEROZ = MAXZ;
  const char *BS_ID = eID_SET.Data();
 
  if( eDB->AddEventBrick(Form(
      "%d, %12.2f, %12.2f, %12.2f, %12.2f, %12.2f, %12.2f, %s, %d, %12.2f, %12.2f, %12.2f",
      eEventBrick, MINX, MAXX, MINY, MAXY, MINZ, MAXZ, BS_ID, eBrick, ZEROX, ZEROY, ZEROZ
                             )) )
  {
    //========== Adding template mark sets ==========//
    EdbMarksBox *mbOL = msOL.GetAbsolute();
    for (int imarks=0;imarks<mbOL->GetN();imarks++)
    {
      EdbMark *mark = mbOL->GetMark(imarks);
      const char *shape = eX_marks? "'L'" : "'S'";
      eDB->AddTemplateMarkSets(Form(
          "%lld, %d, %f, %f, %d, %d, %s, %d",
      eEventBrick,
      mark->GetID(),
      mark->GetX(),
      mark->GetY(),
      1,2,                          //markrow, markcol (boh...)
      shape,
      mark->Flag()
                                   ));
    }
    //========== Adding plates ======================//
    TString filename=Form("%s/b%06d/b%06d.geometry",sproc.eProcDirClient.Data(),eBrick,eBrick);
    FILE *fp=0;
    if ((fp=fopen( filename.Data(), "r" ))==NULL) {
      Log(1,"AddBrick","ERROR! Cannot open file %s",filename); return;
    }
    while (!feof(fp))
    {
      int iplate;
      float z;
      if (fscanf(fp,"%d %f",&iplate,&z)!=2) continue;
      char dataplate[50];
      sprintf(dataplate,"%d, %12.2f",iplate, z);
      eDB->AddPlate( eEventBrick, dataplate);
    }
  }
  else eERROR++;
}

AddHeaderOperation()

ULong64_t EdbScan2DB::AddHeaderOperation

(

const char *

note = ""

)

{
  return  eDB->AddProcessOperation(
      eIdMachine,
  eHeaderProgramsettings,
  eIdRequester,
  0,                       // id_parent_operation
  eEventBrick,
  0,                       // id_plate
  2,                       // driverlevel
  0,                       // Id_plate_calibrations : Null on Header Operation
  eDB->Timestamp(),        // starttime
  eDB->Timestamp(),        // finishtime
  "'Y'",
  notes                    // notes
                                              );
}

DumpListOfHeaderOperations()

void EdbScan2DB::DumpListOfHeaderOperations

(

)

{
  eDB->MyQuery( Form(
      "select ID,to_char(starttime),to_char(notes) from opera.tb_proc_operations where \
      id_eventbrick=%lld and id_programsettings=%s",
      eEventBrick, 
      eDB->Ostr(eHeaderProgramsettings)
              ));
  eDB->MyQuery( Form(
      "select ID,to_char(starttime),to_char(notes) from opera.tb_proc_operations where \
      id_eventbrick=%lld and id_programsettings=%s",
      eEventBrick,
      eDB->Ostr(eFeedbackProgramsettings)
                    ));
}

InitDB()

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

{
  eDB = new TOracleServerE2WX( conn, user, pwd );
  if(!eDB) return 0;
  eDB->SetTransactionRW();
  return 1;
}

LoadCalibration()

void EdbScan2DB::LoadCalibration	(	EdbScanProc &	sproc,
		EdbID	edbid
	)

{
  Log( 2,"EdbScan2DB::LoadCalibration","Load dataset: %s",edbid.AsString() );
  if(!eDB)    return;
  
  eCalibrationHeaderOperation = AddHeaderOperation("Calibration");
 
  EdbScanSet *ss = sproc.ReadScanSetGlobal(edbid, eX_marks);
  if(ss) 
  {
    int n = ss->eIDS.GetEntries();
    for(int i=0; i<n; i++) 
    {
      EdbID *id  = ss->GetID(i);
      EdbPlateP *plate = ss->GetPlate(id->ePlate);
      if(plate) 
      {
        ULong64_t plateCalibrationOperation =  eDB->AddProcessOperation(
            eIdMachine,
        eCalibrationProgramsettings,
        eIdRequester,
        eCalibrationHeaderOperation, // id_parent_operation
        eEventBrick,
        id->ePlate,          // id_plate
        1,                   // driverlevel
        0,                   // calibration operation : NULL for Header Operation
        eDB->Timestamp(),    // starttime
        eDB->Timestamp(),    // finishtime
        "'Y'",
        "Calibration area"          // notes
                                                     );
        eDB->AddPlateCalibration(eEventBrick, plateCalibrationOperation, plate);  // load Aff
 
        if(eWriteRawCalibrationData)  {
          ULong64_t id_calib_zone = LoadCalibrationZone( sproc, *id, plateCalibrationOperation );
          //
          //========== Adding views and their microtracks ==========//
          EdbRunTracking rt;
          rt.ePredictionScan=true;
          sproc.InitRunAccess( rt, *id );
          eDB->AddViews(rt, eEventBrick, id_calib_zone, true);
          int nvpa = rt.GetNviewsPerArea();
          //
          //========= Adding basetracks assuming that microtracks already added ==========//
          EdbDataPiece dp;
          sproc.MakeFileName(dp.eFileNameCP,*id,"cp.root");
          dp.InitCouplesTree();
          eDB->AddBaseTracks(dp.eCouplesTree, eEventBrick, id_calib_zone, nvpa, true);
          dp.CloseCPData();
        }
      }
    }
  }
}

LoadCalibrationZone()

ULong64_t EdbScan2DB::LoadCalibrationZone	(	EdbScanProc &	sproc,
		EdbID	edbid,
		ULong64_t	operation
	)

{
  EdbPattern pred;
  sproc.ReadPred(pred,id,-1);
  EdbSegP *spred = pred.GetSegment(0);
  if(!spred) return 0;
  
  return eDB->MyQueryInsertReturning(
      Form("INSERT INTO OPERA.TB_ZONES (ID_EVENTBRICK, ID_PLATE, ID_PROCESSOPERATION, \
      MINX, MAXX, MINY, MAXY, RAWDATAPATH, STARTTIME, ENDTIME, SERIES,\
      TXX, TXY, TYX, TYY, TDX, TDY) VALUES \
      (%s, %s, %s, %.2f, %.2f, %.2f, %.2f, %s, %s, %s, %s, 1, 0, 0, 1, 0, 0)",
          eDB->Ostr(eEventBrick),
          eDB->Ostr(id.ePlate),
          eDB->Ostr(operation),
          spred->X() - spred->SX(),
          spred->X() + spred->SX(),
          spred->Y() - spred->SY(),
          spred->Y() + spred->SY(),
          "'Local RawdataPath'",
          eDB->Timestamp(),
          eDB->Timestamp(),
          eDB->Ostr(id.eMajor)  // or minor?
          ), "ID");
}

LoadPrediction()

void EdbScan2DB::LoadPrediction	(	EdbScanProc &	sproc,
		EdbID	edbid
	)

{
  Log( 1,"EdbScan2DB::LoadPrediction","Load dataset: %s",edbid.AsString() );
  ePredictionHeaderOperation = AddHeaderOperation("Prediction");
  EdbScanSet *ss = sproc.ReadScanSet(edbid);
 
  EdbID *idstart = ss->GetID(0);
  TString str;
  sproc.MakeFileName(str,*idstart,"sbt.root");
  EdbRunTracking rtpath;
  rtpath.ePredictionScan=true;
  TTree *t = rtpath.InitSBtree(str.Data(),"READ");
  
  int nsbt = (int) t->GetEntries();
  for (int ipath=0;ipath<nsbt;ipath++) {                             // scanback paths of most downstream plate  (could be connected to CS
    rtpath.GetSBtreeEntry(ipath, *t);
    eDB->AddScanbackPath( eEventBrick, ePredictionHeaderOperation,
                          rtpath.ePred.ID(),idstart->ePlate,eIsBlackCS );
  }
  rtpath.CloseSBtree(t);
  
  
  for (int ip=0; ip<ss->eIDS.GetEntries(); ip++)
  {
    EdbID *id = ss->GetID(ip);
    EdbPlateP *plate = ss->GetPlate(id->ePlate);
 
    ULong64_t id_calibration_operation = eDB->GetProcessOperationID (
        eEventBrick,
        eCalibrationHeaderOperation,
        eCalibrationProgramsettings,
        id->ePlate
                                   );
    ULong64_t platePredictionOperation =  eDB->AddProcessOperation(  // Adding prediction operation
        eIdMachine,
    ePredictionProgramsettings,
    eIdRequester,
    ePredictionHeaderOperation,       // id_parent_operation
    eEventBrick,
    plate->ID(),            // id_plate
    1,                      // driverlevel
    id_calibration_operation,  // calibration operation : NULL for Header Operation
    eDB->Timestamp(),       // starttime
    eDB->Timestamp(),       // finishtime
    "'Y'",
    "Prediction area"          // notes
                                                     );
    LoadSBData(sproc,*id, platePredictionOperation);
  }
}

LoadSBData()

void EdbScan2DB::LoadSBData	(	EdbScanProc &	sproc,
		EdbID	id,
		ULong64_t	operation
	)

{
  // Do not load all microtracks but only one's assigned to path
  //======== load scanback data for one plate ==============//
 
  TString rstr;
  sproc.MakeFileName( rstr, id, "sbt.root" );
  EdbRunTracking rtsb;
  rtsb.ePredictionScan=true;
  Log(1,"EdbScan2DB::LoadSBData","open %s",rstr.Data());
  TTree *tsbt = rtsb.InitSBtree(rstr.Data(),"READ");
  if(tsbt)
  {
    int nsbt = (int) tsbt->GetEntries();
 
    int id_basetrack=1;
    for (int ipath=0;ipath<nsbt;ipath++)
    {
      rtsb.GetSBtreeEntry( ipath, *tsbt);
      ULong64_t id_path = eDB->GetId_ScanbackPath(
          eEventBrick, 
          ePredictionHeaderOperation, 
          rtsb.ePred.ID() 
                                                 );
      if(!id_path) {
        eDB->AddScanbackPath( eEventBrick, operation, rtsb.ePred.ID(), id.ePlate, 1 );
        id_path = eDB->GetId_ScanbackPath( eEventBrick, operation, rtsb.ePred.ID() );
      }
      ULong64_t id_pred_zone = LoadZone( rtsb.ePred, id.ePlate, operation,
                                         id_path, "'Local RawdataPath'");
 
      //========= Adding views and their microtracks ==========//
      int   id_view = id_path;
      int   side[2]={1,2};
      float zd[2]={214+45,0}, zu[2]={214,-45};
      for(int iside=0; iside<2; iside++)           // add up/down views
      {
        eDB->MyQuery( Form(
            "INSERT INTO OPERA.TB_VIEWS (ID_EVENTBRICK, ID_ZONE, SIDE, ID, DOWNZ, UPZ, POSX, POSY)\
            VALUES (%s, %s, %d, %d, %.2f, %.2f, %.2f, %.2f)",
        eDB->Ostr(eEventBrick),
        eDB->Ostr(id_pred_zone),
        side[iside],
        id_view,
        zd[iside],
        zu[iside],
        rtsb.ePred.X(),
        rtsb.ePred.Y()
                          ));
      }
      EdbSegP s,s1,s2;
      if( rtsb.GetSegmentsForDB(s,s1,s2) >=0 )
      {
        int id_down=1;
        int id_up=1;
        s1.SetID(id_up);
        s2.SetID(id_down);
        eDB->AddMicroTrack( eEventBrick, id_pred_zone, 2, id_view, s1 );
        printf("z = %f\n",s1.Z());
        eDB->AddMicroTrack( eEventBrick, id_pred_zone, 1, id_view, s2 );
        printf("z = %f\n",s2.Z());
        eDB->AddBaseTrack( Form(
            "%s, %s ,%d, %2f, %2f, %2f, %2f, %2f, %2f, %2f, %d, %ld, %d, %ld",
        eDB->Ostr(eEventBrick),
        eDB->Ostr(id_pred_zone),
        id_basetrack,
        rtsb.eNext.X(), rtsb.eNext.Y(),
        rtsb.eNext.TX(),rtsb.eNext.TY(),
        rtsb.eNext.W(), rtsb.eNext.Volume(), rtsb.eNext.Chi2(),
        1, id_down, 2, id_up
                               ));
      }
      else   // no any candidates
      {
        id_basetrack=0;
      }
      eDB->AddScanbackPrediction( Form(
          "%s, %s ,%d, %f, %f, %f, %f, NULL, NULL, NULL, NULL, NULL, %s, %s,'N', %d",
      eDB->Ostr(eEventBrick),
      eDB->Ostr(id_path),
      id.ePlate,
      rtsb.ePred.X(), 
      rtsb.ePred.Y(), 
      rtsb.ePred.TX(), 
      rtsb.ePred.TY(),
      eDB->Ostr(id_pred_zone),
      eDB->Ostr(id_basetrack),
      0
                                      ));
    }
    rtsb.CloseSBtree(tsbt);
  }
  else
  {
    Log(1,"EdbScan2DB::LoadSBData","ERROR! can not open %s!",rstr.Data());
  }
}

LoadSBDataOld()

void EdbScan2DB::LoadSBDataOld	(	EdbScanProc &	sproc,
		EdbID	id,
		ULong64_t	operation
	)

! Deprecated due to a problem of duplication of all raw data for each prediction - useless and time consuming =VT:2/08/2017

{
  //======== load scamback data for one plate ==============//
  
  TString rstr;
  sproc.MakeFileName( rstr, id, "sbt.root" );
  EdbRunTracking rtsb;    rtsb.ePredictionScan=true;
  TTree *tsbt = rtsb.InitSBtree(rstr.Data(),"READ");
  int nsbt = (int) tsbt->GetEntries();
 
  int id_basetrack=1;
  for (int ipath=0;ipath<nsbt;ipath++)
  {
    //=================== For each path ================//
    rtsb.GetSBtreeEntry( ipath, *tsbt);
    ULong64_t id_path = eDB->GetId_ScanbackPath( eEventBrick, ePredictionHeaderOperation, rtsb.ePred.ID() );
    if(!id_path) { 
      eDB->AddScanbackPath( eEventBrick, operation, rtsb.ePred.ID(), id.ePlate, 1 );
      id_path = eDB->GetId_ScanbackPath( eEventBrick, operation, rtsb.ePred.ID() );
    }
    //char *SERIES = id_path;
    // SERIES = 101,102 or 103 (intercalibration with 3 zones)
    // SERIES = 0              (intercalibration with a single zone)
    // SERIES = PATH_ID        (zone coming from a scan-back)
    // SERIES = ???            (zone coming from a total-scan)
    /*********** Adding one path-predicition zone ***********/
    ULong64_t id_pred_zone = LoadZone( rtsb.ePred, id.ePlate, operation,
                                       id_path, "'Local RawdataPath'");
 
    //========= Adding views and their microtracks ==========//
    EdbRunTracking rt;
    rt.ePredictionScan=true;
    sproc.InitRunAccess( rt, rtsb.eIdf );
    eDB->AddViews(rt, eEventBrick, id_pred_zone, true);
    int nvpa = rt.GetNviewsPerArea();
    EdbRun  *run  = rt.GetRun();
 
    Long_t id_view_up   = 0;
    Long_t id_view_down = 0;
    Long_t id_up        = 0;
    Long_t id_down      = 0;
    if (rtsb.eStatus==0) // in case of basetrack found
    {
      id_view_down = (rtsb.eS1.Aid(0))*nvpa+rtsb.eS1.Aid(1);
      id_view_up   = (rtsb.eS2.Aid(0))*nvpa+rtsb.eS2.Aid(1);
      id_down = id_view_down*100000 + 10000*1 + rtsb.eS1.Vid(1)%100000;
      id_up   = id_view_up  *100000 + 10000*2 + rtsb.eS2.Vid(1)%100000;
      Log(2,"EdbScan2DB::LoadSBData","Add BT (with top mt and bottom mt, nvpa=%d) id_down=%ld id_up=%ld",nvpa,id_down,id_up);
    }
    else if (rtsb.eStatus==1) // in case of microtrack bottom found
    {
      id_view_down = (rtsb.eS1.Aid(0))*nvpa+rtsb.eS1.Aid(1);
      id_view_up   = (rtsb.eS1.Aid(0))*nvpa+rtsb.eS1.Aid(1);
      id_down = id_view_down*100000 + 10000*1 + rtsb.eS1.Vid(1)%100000;
      id_up   = id_view_up  *100000 + 10000*2 + rtsb.eS1.Vid(1)%100000 + 20000;
 
      EdbView *view = run->GetEntry(rtsb.eS1.Vid(0));
      float dz = view->GetHeader()->GetZ2()-view->GetHeader()->GetZ3();
 
        // adding fake mt top
      eDB->AddMicroTrack( Form(
          "%s, %s ,%d, %d, %d, %2f, %2f, %2f, %2f, %2f, %2f, %2f",
      eDB->Ostr(eEventBrick),
      eDB->Ostr(id_pred_zone),
      2, id_up, id_view_up,
      rtsb.eS1.X() - dz*rtsb.eS1.TX(), rtsb.eS1.Y() - dz*rtsb.eS1.TY(),
      rtsb.eS1.TX(), rtsb.eS1.TY(), 
      0, 0, -1
                              ));
      Log(2,"EdbScan2DB::LoadSBData","Fake MT bottom added (and BT with MT top real and MT bottom fake)");
    }
    else if (rtsb.eStatus==2) // in case of microtrack top found
    {
      id_view_down = (rtsb.eS2.Aid(0))*nvpa+rtsb.eS2.Aid(1);
      id_view_up   = (rtsb.eS2.Aid(0))*nvpa+rtsb.eS2.Aid(1);
      id_down = id_view_down*100000 + 10000*1 + rtsb.eS2.Vid(1)%100000 + 20000;
      id_up   = id_view_up  *100000 + 10000*2 + rtsb.eS2.Vid(1)%100000;
 
      EdbView *view = run->GetEntry(rtsb.eS2.Vid(0));
      float dz = view->GetHeader()->GetZ2()-view->GetHeader()->GetZ3();
 
        // adding fake mt bottom
      eDB->AddMicroTrack( Form(
          "%s, %s ,%d, %d, %d, %2f, %2f, %2f, %2f, %2f, %2f, %2f",
      eDB->Ostr(eEventBrick),
      eDB->Ostr(id_pred_zone),
      1, id_down, id_view_down,
      rtsb.eS2.X() - dz*rtsb.eS2.TX(), 
      rtsb.eS2.Y() - dz*rtsb.eS2.TY(),
      rtsb.eS2.TX(), 
      rtsb.eS2.TY(),
      0, 0, -1
                              ));
      Log(2,"EdbScan2DB::LoadSBData","Fake MT top added (and BT with MT bottom real and MT top fake)");
    }
    /*   
    else // no any candidates (stat=-1)
    {
    id_view_up=0;
    id_view_down=0;
    id_down = 10000*1 + id_basetrack;
    id_up   = 10000*2 + id_basetrack;
    float dz = 200;
    eDB->AddMicroTrack( Form(
    "%s, %s ,%d, %d, %d, %2f, %2f, %2f, %2f, %2f, %2f, %2f",
    eDB->Ostr(eEventBrick),
    eDB->Ostr(id_pred_zone),
    2, id_up, id_view_up,
    rtsb.eS1.X() - dz*rtsb.eS1.TX(), rtsb.eS1.Y() - dz*rtsb.eS1.TY(),
    rtsb.eS1.TX(), rtsb.eS1.TY(), 
    0, 0, -1
                              ));
  }
    */
    if(rtsb.eStatus==0||rtsb.eStatus==1||rtsb.eStatus==2) // exist some candidate
    {
      eDB->AddBaseTrack( Form(
          "%s, %s ,%d, %2f, %2f, %2f, %2f, %2f, %2f, %2f, %d, %ld, %d, %ld",
      eDB->Ostr(eEventBrick),
      eDB->Ostr(id_pred_zone),
      id_basetrack,
      rtsb.eNext.X(), rtsb.eNext.Y(),
      rtsb.eNext.TX(),rtsb.eNext.TY(),
      rtsb.eNext.W(), rtsb.eNext.Volume(), rtsb.eNext.Chi2(),
      1, id_down, 2, id_up
                             ));
      eDB->AddScanbackPrediction( Form(
          "%s, %s ,%d, %f, %f, %f, %f, NULL, NULL, NULL, NULL, NULL, %s, %s,'N', %d",
      eDB->Ostr(eEventBrick),
      eDB->Ostr(id_path),
      id.ePlate,
      rtsb.ePred.X(), 
      rtsb.ePred.Y(), 
      rtsb.ePred.TX(), 
      rtsb.ePred.TY(),
      eDB->Ostr(id_pred_zone),
      eDB->Ostr(id_basetrack),
      0
                                      ));
      id_basetrack++;
    }
    else   // no any candidates
    {
      eDB->AddScanbackPrediction( Form(
          "%s, %s ,%d, %f, %f, %f, %f, NULL, NULL, NULL, NULL, NULL, %s, %s,'N', %d",
      eDB->Ostr(eEventBrick),
      eDB->Ostr(id_path),
      id.ePlate,
      rtsb.ePred.X(), 
      rtsb.ePred.Y(), 
      rtsb.ePred.TX(), 
      rtsb.ePred.TY(),
      eDB->Ostr(id_pred_zone),
      eDB->Ostr(0),
      0
                                      ));
    }
  }
  rtsb.CloseSBtree(tsbt);
}

LoadVolume()

void EdbScan2DB::LoadVolume	(	EdbScanProc &	sproc,
		EdbID	edbid,
		EdbID	idstop
	)

{
  Log( 2,"EdbScan2DB::LoadVolume","Load dataset: %s",idvol.AsString() );
  if(!eDB)    return;
  
  eVolumeHeaderOperation = AddHeaderOperation("Volume");
  
  EdbScanSet *ss = sproc.ReadScanSet(idvol);
  if(ss) 
  {
    ULong64_t id_volume = eDB->AddVolume(eEventBrick, eVolumeHeaderOperation, idvol.eMajor );
 
    int n = ss->eIDS.GetEntries();
    for(int i=0; i<n; i++) {
      EdbID *id  = ss->GetID(i);
      EdbPlateP *plate = ss->GetPlate(id->ePlate);
 
      if(plate) {
 
        ULong64_t plateVolumeOperation =  eDB->AddProcessOperation(  // Adding volume operation
            eIdMachine,
        eVolumeProgramsettings,
        eIdRequester,
        eVolumeHeaderOperation,    // id_parent_operation
        eEventBrick,
        id->ePlate,          // id_plate
        1,                   // driverlevel
        0,                   // calibration operation : NULL for Header Operation
        eDB->Timestamp(),    // starttime
        eDB->Timestamp(),    // finishtime
        "'Y'",
        "Volume area"          // notes
                                                    );
        EdbPattern pred;
        sproc.ReadPred( pred, *id, -1 );
        EdbSegP *spred = pred.GetSegment(0);
        ULong64_t id_volume_zone = LoadZone( *spred, id->ePlate, plateVolumeOperation, id_volume, "'Local RawdataPath'");
 
        //============= Loading views and their microtracks ==========//
        EdbRunTracking rt;
        rt.ePredictionScan=true;
        sproc.InitRunAccess( rt, *id );
        eDB->AddViews(rt, eEventBrick, id_volume_zone, true);
        int nvpa = rt.GetNviewsPerArea();
          
        //========= Adding basetracks assuming that microtracks already added ==========//
        EdbDataPiece dp;
        sproc.MakeFileName(dp.eFileNameCP,*id,"cp.root");
        dp.InitCouplesTree();
        eDB->AddBaseTracks(dp.eCouplesTree, eEventBrick, id_volume_zone,nvpa, true);
        dp.CloseCPData();
        
        //=========== Adding volume slice ==========//
        eDB->MyQuery(Form("\
            INSERT INTO OPERA.TB_VOLUME_SLICES \
            (ID_EVENTBRICK, ID_VOLUME, ID_PLATE, MINX, MINY, MAXX, MAXY, ID_ZONE, DAMAGED) \
            VALUES (%lld, %s, %d, %.2f, %.2f, %.2f, %.2f, %s, %s)",
                eEventBrick,
                eDB->Ostr(id_volume),
                id->ePlate,
                spred->X() - spred->SX(),
                spred->X() + spred->SX(), 
                spred->Y() - spred->SY(),
                spred->Y() + spred->SY(), 
                eDB->Ostr(id_volume_zone),
                "'N'"                     //'N' - for "not damaged"
                    ));
 
      }
    }
    if (eIDPATH>=0) {
      //====== Read path informations ======//
      TString filename;
      sproc.MakeFileName(filename,idstop,"stopping_points.txt",false);
      EdbPattern pat;
      sproc.ReadPatTXT(filename, pat);
      int id_stopping_plate=0;
      for (int ip=0;ip<pat.N();ip++)
      {
        EdbSegP *s = pat.GetSegment(ip);
        s->SetPID(s->Flag());
        s->SetFlag(0);
        if (s->ID()==eIDPATH) id_stopping_plate=s->PID();
      }
      if (!id_stopping_plate) {
        Log(1,"EdbScan2DB::LoadVolume", "ERROR: informations about the path %d not found in %s\n",eIDPATH,filename);
      }
      else
      {
        //========= Adding in TB_B_SBPATHS_VOLUMES ==========//
        eDB->AddBSBpathsVolumes(Form(
            "%lld, %s, %d, %s, %d, %d",
        eEventBrick, 
        eDB->Ostr(ePredictionHeaderOperation),
        eIDPATH,
        eDB->Ostr(eVolumeHeaderOperation),
        idvol.eMajor,
        id_stopping_plate
                                   ));
      }
    }
  }
}

LoadZone()

ULong64_t EdbScan2DB::LoadZone	(	EdbSegP &	s,
		int	plate,
		ULong64_t	operation,
		ULong64_t	series,
		const char *	cmt
	)

{
  return eDB->MyQueryInsertReturning(
      Form("INSERT INTO OPERA.TB_ZONES (ID_EVENTBRICK, ID_PLATE, ID_PROCESSOPERATION, \
      MINX, MAXX, MINY, MAXY, RAWDATAPATH, STARTTIME, ENDTIME, SERIES,\
      TXX, TXY, TYX, TYY, TDX, TDY) VALUES \
      (%s, %s, %s, %.2f, %.2f, %.2f, %.2f, %s, %s, %s, %s, 1, 0, 0, 1, 0, 0)",
  eDB->Ostr(eEventBrick),
  eDB->Ostr(plate),
  eDB->Ostr(operation),
  s.X() - s.SX(),
  s.X() + s.SX(),
  s.Y() - s.SY(),
  s.Y() + s.SY(),
  cmt,
  eDB->Timestamp(),
  eDB->Timestamp(),
  eDB->Ostr(series)
          ), "ID");
}

Print()

void EdbScan2DB::Print

(

)

{
  printf("\n=============== EdbScan2DB settings ================\n");
  printf("eID_SET                     = %s\n"  ,eID_SET.Data());
  printf("eBrick                      = %lld\n", eBrick);
  printf("eEvent                      = %lld\n", eEvent);
  printf("eEventBrick                 = %lld\n",eEventBrick);
  printf("eIdMachine                  = %lld\n",eIdMachine);
  printf("eIdRequester                = %lld\n",eIdRequester );
  printf("eHeaderProgramsettings      = %lld\n",eHeaderProgramsettings);
  printf("eCalibrationProgramsettings = %lld\n",eCalibrationProgramsettings );
  printf("ePredictionProgramsettings  = %lld\n",ePredictionProgramsettings );
  printf("eVolumeProgramsettings      = %lld\n",eVolumeProgramsettings );
  printf("eFeedbackProgramsettings    = %lld\n",eFeedbackProgramsettings );
  printf("eCalibrationHeaderOperation = %lld\n",eCalibrationHeaderOperation );
  printf("ePredictionHeaderOperation  = %lld\n",ePredictionHeaderOperation );
  printf("eVolumeHeaderOperation      = %lld\n",eVolumeHeaderOperation );
  printf("eIsBlackCS                  = %d\n"  , eIsBlackCS);
  if(eDB) {
    printf("=========== Database settings ================\n");
    eDB->Print();
  }
  printf("================================================\n\n");
}

Member Data Documentation

eBrick

ULong64_t EdbScan2DB::eBrick

eCalibrationHeaderOperation

ULong64_t EdbScan2DB::eCalibrationHeaderOperation

eCalibrationProgramsettings

ULong64_t EdbScan2DB::eCalibrationProgramsettings

eDB

TOracleServerE2WX* EdbScan2DB::eDB

eERROR

Int_t EdbScan2DB::eERROR

eEvent

ULong64_t EdbScan2DB::eEvent

eEventBrick

ULong64_t EdbScan2DB::eEventBrick

eFeedbackProgramsettings

ULong64_t EdbScan2DB::eFeedbackProgramsettings

eHeaderProgramsettings

ULong64_t EdbScan2DB::eHeaderProgramsettings

eID_SET

TString EdbScan2DB::eID_SET

eIdMachine

ULong64_t EdbScan2DB::eIdMachine

eIDPATH

Int_t EdbScan2DB::eIDPATH

eIdRequester

ULong64_t EdbScan2DB::eIdRequester

eIsBlackCS

Int_t EdbScan2DB::eIsBlackCS

ePredictionHeaderOperation

ULong64_t EdbScan2DB::ePredictionHeaderOperation

ePredictionProgramsettings

ULong64_t EdbScan2DB::ePredictionProgramsettings

eVolumeHeaderOperation

ULong64_t EdbScan2DB::eVolumeHeaderOperation

eVolumeProgramsettings

ULong64_t EdbScan2DB::eVolumeProgramsettings

eWriteRawCalibrationData

Bool_t EdbScan2DB::eWriteRawCalibrationData

eX_marks

Int_t EdbScan2DB::eX_marks

---

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

• src/libEOracle/TOracleServerE2WX.h
• src/libEOracle/TOracleServerE2WX.cxx