src/LogViewer.cc

#include "LogViewer.hh"
#include "ArgParser.hh"
#include "PtEventView.hh"
#include "PtMwView.hh"
#include "PtFlowHe3View.hh"
#include "PtFlowHe4View.hh"

#include <TObject.h>
#include <TCollection.h>
#include <TList.h>
#include <TPgSQLServer.h>
#include <TSQLResult.h>
#include <TSQLRow.h>
#include <TGraph.h>
#include <TCanvas.h>
#include <TVirtualPad.h>
#include <TH1.h>
#include <TROOT.h>
#include <TDatime.h>
#include <TLatex.h>
#include <TLegend.h>

#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <cstring>

#include <sqlite3.h>

using namespace std;

const string LogViewer::tgCoolingData = "tbl_coolingdata";
const string LogViewer::tgCryoTmpr    = "view_cryo_tmpr";
const string LogViewer::tgFlwHe4      = "view_flw_he4";
const string LogViewer::tgMw          = "view_mw";
const string LogViewer::tgPrssCryo    = "view_prss_cryo";
const string LogViewer::tgPrssHe3     = "view_prss_he3";
const string LogViewer::tgPrssHe4     = "view_prss_he4";

const std::string LogViewer::sqlEpoch    = "EXTRACT(EPOCH FROM datetime)";
const std::string LogViewer::sqlTimeZone = "EXTRACT(TIMEZONE FROM datetime)";

LogViewer::LogViewer( int& argc, char* argv[] ) :
  Switch(),
  TApplication( "logViewer", &argc, argv ),
  server_( NULL ), 
  ptViews_( 0 ),
  opHost_( NULL ), opPort_( NULL ), opUser_( NULL ), opPass_( NULL ),
  opDB_( NULL ), opTable_( NULL ), opStart_( NULL ), opEnd_( NULL ),
  opList_( NULL ), opView_( NULL ), 
  opTitleSize_( NULL ), opTitleOffset_( NULL ),
  opLabelSize_( NULL ), opEventLog_( NULL ),
  opTLeftMargin_( NULL ), opTRightMargin_( NULL ),
  c_( NULL ),
  tmin_( 0 ), tmax_( 0 ), twidth_( 0 ), toffset_( 0 ),
  tLeftMargin_( 0.1 ), tRightMargin_( 0.15 )
{
  
  this->setupOptions( argc, argv );
  
  if( c_ == NULL ) 
    c_ = new TCanvas( "logViewCanvas", "PT Log Viewer", 1169, 827 );

  // To be carefull to call addView or setup..View method.
  // At the moment, only 8 pads are created.
  // The number of views must be less than 8, including event log view.
  // So 7 view at maximum are allowd to be created.
  c_->Divide( 1, 8, 1, 0 );
  
  this->setupCryoTmprView();          // Cryostat temperature 
  this->setupPrssCryoView();          // Cryostat pressure
  this->setupPrssHe3View();           // He-3 Pressure
  this->addView( new PtFlowHe3View ); // He-3 Flow
  this->setupPrssHe4View();           // He-4 Pressure
  this->addView( new PtFlowHe4View ); // He-4 Flow
  this->addView( new PtMwView );
  
  // event view must be addted at the end  
  ptViews_.push_back( new PtEventView );;
  ptViews_.back()->pad( c_->cd( 1 ) ); 
  
  tmin_ = this->parseTimeStr( this->startTime() );
  tmax_ = this->parseTimeStr( this->endTime() );
  twidth_ = tmax_ - tmin_;

  this->connect();
}

LogViewer::~LogViewer(){
  if( server_ ) server_->Close();
  for( int i = 0; i < ptViews_.size(); i++ ) delete ptViews_[ i ];
}

int LogViewer::parseTimeStr( const std::string& data ){
  struct tm t;
  memset( &t, 0, sizeof( struct tm ) );
  strptime( data.c_str(), "%F %T %z", &t );
  return mktime( &t );
}

void LogViewer::setupOptions( const int& argc, char* argv[] ){
  
  // option handling preperation
  opHost_ = new ArgParser( ArgParser::REQUIRED, "133.24.27.182",
                           "server IP address" );
  opPort_ = new ArgParser( ArgParser::REQUIRED, "58163",
                           "Port number" );
  opUser_ = new ArgParser( ArgParser::REQUIRED, "ptlab", "user name" );
  
  opPass_ = new ArgParser( ArgParser::REQUIRED, "80MHz", "password" );

  opDB_   = new ArgParser( ArgParser::REQUIRED, "ptdata", "DB name" );
  
  opTable_ = new ArgParser( ArgParser::REQUIRED, "tbl_coolingdata",
                            "Table name" );
  
  opStart_ = new ArgParser( ArgParser::REQUIRED, "2012-03-30 08:00:00+9",
                            "Stat time stamp:  ex.) 2012-03-30 08:00:00+9" );
  
  opEnd_ = new ArgParser( ArgParser::REQUIRED, "2012-03-31 00:00:00+9",
                          "End time stamp:  ex.) 2012-03-30 24:00:00+9" );
  
  opList_ = new ArgParser( ArgParser::OPTIONAL, "", "List data name" );

  opView_ = new ArgParser( ArgParser::REQUIRED, "all",
                           tgCryoTmpr + "|" + tgFlwHe4 + "|" + tgMw + "|" + 
                           tgPrssCryo + "|" + tgPrssHe3 + "|" + tgPrssHe4 );
  
  opTitleSize_ = new ArgParser( ArgParser::REQUIRED, "0.11",
                                "Y-axis Title Font Size" );
  
  opTitleOffset_ = new ArgParser( ArgParser::REQUIRED, "0.3",
                                  "Y-axis Title Offset" );
  
  opLabelSize_ = new ArgParser( ArgParser::REQUIRED, "0.1",
                                "Y-axis Label Font Size" );
  
  opEventLog_ = new ArgParser( ArgParser::REQUIRED, "ptlog.db3",
                               "Event Log DB file name" );
  
  opTLeftMargin_ = new ArgParser( ArgParser::REQUIRED, "0.05",
                                  "Time Window Left Margin" );
  
  opTRightMargin_ = new ArgParser( ArgParser::REQUIRED, "0.15",
                                   "Time Window Right Margin" );
  
  opOutput_ = new ArgParser( ArgParser::REQUIRED, "PT_LOG",
                             "Output file basename" );
  
  Switch& opt = this->option();
  opt[ "host" ]     = opHost_;
  opt[ "port" ]     = opPort_; 
  opt[ "user" ]     = opUser_;
  opt[ "password" ] = opPass_;
  opt[ "db" ]       = opDB_;
  opt[ "table" ]    = opTable_;
  opt[ "start" ]    = opStart_;
  opt[ "end" ]      = opEnd_;
  opt[ "list" ]     = opList_;
  opt[ "view" ]     = opView_;
  opt[ "tSize" ]    = opTitleSize_;
  opt[ "tOffset" ]  = opTitleOffset_;
  opt[ "lSize" ]    = opLabelSize_;
  opt[ "eventLog" ] = opEventLog_;
  opt[ "margin-left" ] = opTLeftMargin_;
  opt[ "margin-right" ] = opTRightMargin_;
  opt[ "output" ]   = opOutput_;
  
  // parse the arguments list
  vector< string > args( argc );
  for( int i = 0; i < argc; i++ ) args[ i ] = string( argv[ i ] );
  this->parse( args );
  
}

// ----------------------------------------------------------------------- //
//
//
//
// ----------------------------------------------------------------------- //
PtView* LogViewer::addView( PtView *view ){
  ptViews_.push_back( view );
  PtView* v = ptViews_.back();
  if( c_ != NULL )  v->pad( c_->cd( ptViews_.size() + 1 ) );
  return v;
}

PtView* LogViewer::addView(){
  return this->addView( new PtView );
}

PtView* LogViewer::setupCryoTmprView(){
  
  PtView& v = *( this->addView() );
  
  v.name()  = tgCryoTmpr;
  v.title() = "Temperature";
  
  v.add( "sep",       "Separator",  kMagenta );
  v.add( "evap",      "Evaporator", kGreen );
  v.add( "still",     "Still",      kCyan );
  v.add( "stillref",  "Still(Ref)", kBlue );
  v.add( "mc",        "M.C.",       kRed );

  return &v;
}

PtView* LogViewer::setupPrssCryoView(){
  
  PtView& v = *( this->addView() );

  v.name() = tgPrssCryo;
  v.title() = "Press. (Cryo)";
  v.pad()->SetLogy( true );

  v.add( "pirani",    "Pirani", kBlue );
  v.add( "cc10",      "CC10",   kRed );

  return &v;
}

PtView* LogViewer::setupPrssHe3View(){
  
  PtView& v = *( this->addView() );

  v.name() = tgPrssHe3;
  v.title() = "Press. (He3)";
  v.pad()->SetLogy( true );
  
  v.add( "inlet",       "In-let",  kCyan );
  v.add( "outlet",      "Out-let", kMagenta );

  return &v;
}

PtView* LogViewer::setupPrssHe4View(){
  
  PtView& v = *( this->addView() );

  v.name() = tgPrssHe4;
  v.title() = "Press. (He4)";
  v.pad()->SetLogy( true );

  v.add( "he4b1",     "Booster", kBlue );
  v.add( "he4vp",     "Vapour",  kRed );

  return &v;
}

std::string LogViewer::url() const {
  return 
    string( "pgsql://" ) + (*opHost_)() + string(":") +
    (*opPort_)() + string("/") + (*opDB_)();
}

void LogViewer::connect(){
  if( server_ == NULL ){
    cout << "Connecting: " << this->url() << endl;
    server_ = 
      new TPgSQLServer( this->url().c_str(), (*opUser_)().c_str(), (*opPass_)().c_str() );
  }
}

std::string LogViewer::startTime(){
  return (*opStart_)();
}

std::string LogViewer::endTime(){
  return (*opEnd_)();
}

void LogViewer::printList(){
  
  if( server_ == NULL ) this->connect();
  
  string sql = 
    "SELECT column_name FROM information_schema.columns WHERE table_catalog='ptdata' and table_name='tbl_coolingdata' ORDER BY ordinal_position";
  
  TSQLResult *res = server_->Query( sql.c_str() );
  int nField = res->GetFieldCount();
  TSQLRow    *row;
  while( row = res->Next() ){
    for( int i = 0; i < nField; i++ ){
      cout << row->GetField( i ) << endl;
    }
  }

}

void LogViewer::run(){
  
  
  Switch& opt = this->option();
  if( opt[ "help" ]->exist() ) return;


  if( opList_->exist() ) this->printList();
  else {
    if( (*opView_)() != "all" ) {
      //      vector< PtView* >::iterator itr
      //        std::find( ptViews_.begin(), ptViews_.end(), PtView( (*opView_)() ) );
      //      if( itr != ptViews_.end() ) this->query( *itr );
    } else {
      
      // load data at first
      cout << "Fetching LOG data... " << endl;
      for( int i = 0; i < ptViews_.size(); i++ ) {
        ptViews_[ i ]->query( this );
        ptViews_[ i ]->draw();
        ptViews_[ i ]->analysis();
        c_->Draw();
      }
      
      c_->Print( string( (*opOutput_)() + ".png" ).c_str() );
      c_->Print( string( (*opOutput_)() + ".pdf" ).c_str() );
      
    }
  }

}

double LogViewer::tleft(){
  return atof( (*opTLeftMargin_)().c_str() );
}

double LogViewer::tright(){
  return atof( (*opTRightMargin_)().c_str() );
}

double LogViewer::tmin(){
  return tmin_ - this->tleft() * twidth_ - toffset_;
}

double LogViewer::tmax(){
  return tmax_ + this->tright() * twidth_ - toffset_;
}

double LogViewer::labelSize(){
  return atof( (*opLabelSize_)().c_str() );
}

double LogViewer::titleSize(){
  return atof( (*opTitleSize_)().c_str() );
}

double LogViewer::titleOffset(){
  return atof( (*opTitleOffset_)().c_str() );
}


std::string LogViewer::output(){
  return (*opOutput_)();
}

std::string LogViewer::eventLog(){
  return (*opEventLog_)();
}