AbstractObjectStock.cxx

Go to the documentation of this file.

#include "AbstractObjectStock.h"

#include "THStock.h"

// For ROOT dictionary 
ClassImp ( AbstractObjectStock )

// this function is set up in the header file !
// just need to include THStock in the header
// could be deleted...all the file !
AbstractObjectStock::AbstractObjectStock () : TObject()
{
/*
#ifdef DEBUG
  std::cout << "Entry Constructor AbstractObjectStock " << std::endl; // fname << std::endl;
#endif
*/
  kPaint = true;
  fParentTHStock=0;
}

// less ambitious, just regroup the computation but keeps Hparam_stock for test
void IndicatorObjectStock::ComputeBinRange ( ListDataStockBase *ldata, CommonXAxis *fcommon_xaxis_th, Hparam_stock_t & Hparam_stock,
                unsigned int & xfirst, unsigned int & xlast, int & shift_left )
{
#ifdef DEBUG_OBJSTOCK
        std::cout << "\n Entry IndicatorObjectStock::ComputeBinRange " << std::endl;
        std::cout << "Compare Hparam.xlast " << Hparam_stock.xlast << std::endl;
        std::cout << "Faxis->GetLast() " << fcommon_xaxis_th->GetLast() << std::endl;
        std::cout << "Compare Hparam.xfirst " << Hparam_stock.xfirst << std::endl;
    std::cout << "Faxis->GetFirst() " << fcommon_xaxis_th->GetFirst() << std::endl;
#endif

    // not modified, not needed here
        xlast = Hparam_stock.xlast;

        // xlast as computed in THistPainterStock, not recomputed after
        // for the moment, not dependent of the listdata, common on Hparam_stock
        //if ( Hparam_stock.shift_futur > 0 ) {
        //    Hparam_stock.xlast = TMath::Min ( Hparam_stock.xlast, size_data_listd + Hparam_stock.shift_left );}

        //seems fine with fcommon_xaxis
        xfirst = fcommon_xaxis_th->GetFirst();

        // for sure dependent on the ldata, needed here
        unsigned int size_data = ldata->GetSize();
        // can access from common_xaxis
        unsigned int size_axis = fcommon_xaxis_th->GetNbins();
        // or Hparam_stock.shift_futur is in fcommon_axis as well maybe not needed ??
        shift_left = size_axis - size_data - fcommon_xaxis_th->GetShift();

#ifdef DEBUG_OBJSTOCK
        std::cout << "First assign xfirst/xlast " << xfirst << " " << xlast << std::endl;
        std::cout << "shift_left " << shift_left << std::endl;
#endif

        // original method, never override the value of Hparam_stock.xfirst
        xfirst = Hparam_stock.xfirst + shift_left;

        //modify xfirst if the begin slider is > 1
        if ( Hparam_stock.xfirst > 1 ) {
#ifdef DEBUG_OBJSTOCK
               std::cout << " > 1 modify xfirst" << std::endl;
               std::cout << "tmp xfirst " << xfirst << std::endl;
#endif
               xfirst = xfirst - ( Hparam_stock.xfirst - 1 );
               // Assure not larger than the axis
               // seems good...
               xfirst = TMath::Max ( (int)xfirst, (int)Hparam_stock.xfirst );
#ifdef DEBUG_OBJSTOCK
        } else {
            std::cout << "xfirst not modified " << std::endl;
#endif
        }

#ifdef DEBUG_OBJSTOCK
        std::cout << "used GetShift() " << fcommon_xaxis_th->GetShift() << std::endl;
        std::cout << "will return xfirst/xlast " << xfirst << " " << xlast << std::endl;
        std::cout << "will return shift_left " << shift_left << std::endl;
#endif

}

// too ambitious, try to cover all cases without Hparam, will spend lots of time to debug
/*
void IndicatorObjectStock::ComputeBinRange_test ( ListDataStockBase *ldata, CommonXAxis *fcommon_xaxis_th,
                unsigned int & xfirst, unsigned int & xlast, int & shift_left )
{
#ifdef DEBUG
        std::cout << "\n Entry IndicatorObjectStock::ComputeBinRange " << std::endl;
#endif

        xfirst = fcommon_xaxis_th->GetFirst();
        xlast = fcommon_xaxis_th->GetLast();
        // problem with approximation in fXaxis->GetBinLowEdge(last)+fXaxis->GetBinWidth(last);
        // no access to xmax here
        //if ( ( ( Hparam_stock.xmax < ((Double_t)1.0001)) && ( Hparam_stock.xmax > ((Double_t)0.9999) ) ) && ( Hparam_stock.shift_futur > 0 ) )  {
               // here strange way to do, but maybe the best ??
               //Hparam_stock.xlast -= Hparam_stock.shift_futur;



        // for sure dependent on the ldata, needed here
        unsigned int size_data = ldata->GetSize();
        // can access from common_xaxis
        unsigned int size_candle = fcommon_xaxis_th->GetNbins();
        // or Hparam_stock.shift_futur is in fcommon_axis as well maybe not needed ??
        //int shift_left = size_candle - size_data - Hparam_stock.shift_futur;
        shift_left = size_candle - size_data - fcommon_xaxis_th->GetShift();

#ifdef DEBUG
        std::cout << "First assign xfirst/xlast " << xfirst << " " << xlast << std::endl;
        std::cout << "shift_left " << shift_left << std::endl;
#endif

        // not sure of the algorithm here
        unsigned int copy_xfirst = xfirst;
        // now special case
        xfirst = xfirst + shift_left;

        //modify xfirst if needed, which case ??
        if ( copy_xfirst > 1 ) {
            std::cout << " > 1 modify xfirst" << std::endl;
            xfirst = xfirst - ( copy_xfirst - 1 );
            // Assure not larger than the axis
            // yes cannot use Hparam.xfirst if there is a shift_left
            // seems good
            xfirst = TMath::Max ( xfirst, copy_xfirst );
        }

        // modify xlast, because GetLast takes into account the futur
        // need access to Hparam_stock.xmax, to know if the slider is seeing futur
        // not enougth, need to know the position of the last slider
        if ( ( fcommon_xaxis_th->GetShift() > 0 ) && ( fcommon_xaxis_th->GetNbins() > size_data ) ) {
                xlast -= fcommon_xaxis_th->GetShift();
        }


#ifdef DEBUG
        std::cout << "used GetShift() " << fcommon_xaxis_th->GetShift() << std::endl;
        std::cout << "will return xfirst/xlast " << xfirst << " " << xlast << std::endl;
        std::cout << " shift_left " << shift_left << std::endl;
#endif

        return;
}
*/