GRAPH/TFndGraphs.cxx

// @(#)fROOT/GRAPH:$Name:  $:$Id: TFndGraphs.cxx,v 1.7 2007/09/05 09:45:26 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it> 2007/08/03

#include "TFndGraphs.h"
#include "TCanvas.h"

ClassImp(TFndGraph)

// ctors for compatibility with
// the inheritance from TGraph
//   Aug. 2006 (root-5.15/06)
TFndGraph::TFndGraph(): TGraphErrors() {
  InitFnd();
}

TFndGraph::TFndGraph(Int_t n): TGraphErrors(n) {
  InitFnd();
}

TFndGraph::TFndGraph(const TFndGraph &gr):
  TGraphErrors((const TGraphErrors &)(gr))
{
  fFndSum = gr.fFndSum;
  fFndMinX = gr.fFndMinX;
  fFndMaxX = gr.fFndMaxX;
  fFndMinY = gr.fFndMinY;
  fFndMaxY = gr.fFndMaxY;

  fFndMinDrawX = gr.fFndMinDrawX;
  fFndMaxDrawX = gr.fFndMaxDrawX;
  fFndMinDrawY = gr.fFndMinDrawY;
  fFndMaxDrawY = gr.fFndMaxDrawY;

}


//______________________________________
TFndGraph::TFndGraph(const TString &name,const TString &title)
{
  InitFnd(name,title);
}

//______________________________________
void TFndGraph::InitFnd(TString name,TString title){
  
  fFndSum = 0;
  fFndMinX = 0;
  fFndMaxX = 0;
  fFndMinY = 0;
  fFndMaxY = 0;
  SetName(name);    
  SetTitle(title);    
  //
  SetMarkerStyle(21);
  SetMarkerSize(0.7);

  fFndMinDrawX = - K_FinAn_double;
  fFndMaxDrawX = K_FinAn_double;
  fFndMinDrawY = - K_FinAn_double;
  fFndMaxDrawY = K_FinAn_double;
  
}

//______________________________________
Int_t TFndGraph::LoadFromFile(TFile *file){
  // current graph is filled from the given
  // file according to the graph-name ( "this->GetName()" )
  //
  // return value:
  //              0: ok
  //             -1: error

  if(!file){
    Error("LoadSingleGraphFromFile","Pointer to the required file is NULL!");
    return -1;
  }
  //
  if (fNpoints > 0) Reset(kTRUE); // need to keep name/title
  // NOTE: deleting previous graph and ceating a new one
  //       is much faster than resetting the current one

  //
  TFndGraph *grfil =  (TFndGraph *) ( file->Get( GetName() ) );
  if(! grfil ) return -1;
  Double_t px = 0;
  Double_t py = 0;
  Double_t ex = 0;
  Double_t ey = 0;
  for(Int_t p=0;p<grfil->GetN();p++){
    grfil->GetPoint(p,px,py);
    ex = grfil->GetErrorX(p);
    ey = grfil->GetErrorY(p);
    AddPoint(px,py,ex,ey);
  }
  grfil = 0; // deleted lately while closing source file
  
  return 0;
}

//______________________________________
void TFndGraph::Reset(Bool_t keep_name_title){
  // back to original object
  //  NOTE: could be really slow!

  for(Int_t np=0; np<=fNpoints ;np++){
    //     cout << "Removing point: " << np << endl;
    RemovePoint(0);
  }  
  
  TString nam = fName;
  TString tit = fTitle;
  Clear();
  if(keep_name_title){
    fName = nam;
    fTitle = tit;
  }
  //   cout << "num after: " << GetN() << endl;
  fFndSum = 0;
  fFndMinX = 0;
  fFndMaxX = 0;
  fFndMinY = 0;
  fFndMaxY = 0;
  //
  fFndMinDrawX = - K_FinAn_double;
  fFndMaxDrawX = K_FinAn_double;
  fFndMinDrawY = - K_FinAn_double;
  fFndMaxDrawY = K_FinAn_double;
}

//______________________________________
Int_t TFndGraph::EvalAxisRange(){
  // return value: number of actions
  //               0: nothing to do  
  //              -1: error

  //  cout << "...evaluating axis ranges..." << endl;
  TH1F *htmp = GetHistogram();
  if(!htmp){
    Warning("EvalAxisRange","NO HISTOGRAM FOUND IN GRAPH!!!");
    return -1;
  }

  Int_t nact = 0;  
  // ---
  Double_t minx = 0;
  Double_t maxx = 0;
  Double_t miny = 0;
  Double_t maxy = 0;
  GetHistogramLimits(htmp,minx,maxx,miny,maxy);
  //  cout << "-> minx: " << minx << endl;
  //  cout << "-> maxx: " << maxx << endl;
  //  cout << "-> miny: " << miny << endl;
  //  cout << "-> maxy: " << maxy << endl;
  // ---
  
  if(fFndMinDrawX != - K_FinAn_double ){
    if(fFndMinDrawX > minx){
      GetXaxis()->SetRangeUser( fFndMinDrawX, maxx );
      minx = fFndMinDrawX;
      nact++;
    }
    else Warning("EvalAxisRange","minumum set for x-axis too low");
  }
  if(fFndMaxDrawX != K_FinAn_double ){
    if(fFndMaxDrawX < maxx){
      GetXaxis()->SetRangeUser( minx, fFndMaxDrawX );
      nact++;
    }
    else Warning("EvalAxisRange","maxumum set for x-axis too high");
  }
  if(fFndMinDrawY !=  - K_FinAn_double ){
    GetYaxis()->SetRangeUser( fFndMinDrawY, maxy );
    miny = fFndMinDrawY;
    nact++;
  }
  if(fFndMaxDrawY != K_FinAn_double ){
    GetYaxis()->SetRangeUser( miny, fFndMaxDrawY );
    nact++;
  }
  
  
  //  cout << "=========> nact: " << nact << endl;
  //  GetHistogramLimits(htmp,minx,maxx,miny,maxy);
  //   cout << "=== -> minx: " << minx << endl;
  //   cout << "=== -> maxx: " << maxx << endl;
  //   cout << "=== -> miny: " << miny << endl;
  //   cout << "=== -> maxy: " << maxy << endl;
  return nact;
}

//______________________________________
void TFndGraph::SetTimeX(const Bool_t &time_x){
  
  if(time_x){
    GetXaxis()->SetTimeOffset(0);
    GetXaxis()->SetTimeFormat("%d/%m/%y (%H:%M)");
    GetXaxis()->SetTimeDisplay(1);
  }
  else GetXaxis()->SetTimeDisplay(0);
}

//______________________________________
void TFndGraph::DrawDefaults(Bool_t time_x,Color_t col,Width_t width,Option_t *opt,Bool_t sort){

  SetTimeX(time_x);
  EvalAxisRange();
  if(sort) Sort();
  if(col != -1)   SetLineColor(col);
  if(width != -1) SetLineWidth(width);
  Draw(opt);
}

ClassImp(TFndMultiGraph)

//______________________________________
TFndMultiGraph::TFndMultiGraph(TString name,TString title):
  TMultiGraph()
{
  SetName(name);
  SetTitle(title);    
}

//______________________________________
TFndMultiGraph::~TFndMultiGraph(){

}

//______________________________________
void TFndMultiGraph::AddFndGraph(TFndGraph *gr,Option_t *opt,Color_t col,Width_t width){
  //   chopt='L' :  A simple polyline between every points is drawn
  //   chopt='F' :  A fill area is drawn ('CF' draw a smooth fill area)
  //   chopt='A' :  Axis are drawn around the graph
  //   chopt='C' :  A smooth Curve is drawn
  //   chopt='*' :  A Star is plotted at each point
  //   chopt='P' :  Idem with the current marker
  //   chopt='B' :  A Bar chart is drawn at each point
  //   chopt='1' :  ylow=rwymin
  //   chopt='X+' : The X-axis is drawn on the top side of the plot.
  //   chopt='Y+' : The Y-axis is drawn on the right side of the plot.
  
  if(col != -1) gr->SetLineColor(col);
  if(width != -1) gr->SetLineWidth(width);
  
  Add(gr,opt);

  if(fGraphs != 0 && fGraphs->GetEntries() > 1){
    fTitle+=" - ";
    fTitle+=gr->GetTitle();
  }
  else fTitle=gr->GetTitle();
}

//______________________________________
void TFndMultiGraph::EvalAxisRange(){
  if(!fGraphs) return;
  Int_t toten = fGraphs->GetEntries();
  if( toten < 1 ) return;
  
  //  cout << "...evaluating axis ranges..." << endl;

  TAxis *ax = ( GetHistogram() != 0 ) ? GetHistogram()->GetXaxis() : NULL;
  TAxis *ay = GetYaxis();
  if(!ax || !ay){
    Error("EvalAxisRange","NO AXIS FOUND!!!");
    return;
  }

  // values to be set:
  Double_t minx = - K_FinAn_double;
  Double_t maxx =   K_FinAn_double;
  Double_t miny = - K_FinAn_double;
  Double_t maxy =   K_FinAn_double;

  Bool_t at_least_one = kFALSE;  
  TFndGraph *gf = 0;

  // previous values (set):
  Double_t mind_x = - K_FinAn_double;
  Double_t maxd_x =   K_FinAn_double;
  Double_t mind_y = - K_FinAn_double;
  Double_t maxd_y =   K_FinAn_double;

  // previous limits (from graph):
  Double_t lim_p_min_x = - K_FinAn_double; 
  Double_t lim_p_max_x =   K_FinAn_double; 
  Double_t lim_p_min_y = - K_FinAn_double; 
  Double_t lim_p_max_y =   K_FinAn_double; 

  //  cout << "toten: " << toten << endl;

  for(Int_t en=0;en<toten;en++){  
    gf = (TFndGraph *) (fGraphs->At(en) );
    if( gf->EvalAxisRange() > 0 ){
      at_least_one = kTRUE;
    }         
      // current values (set):
      Double_t cur_minx = gf->GetMinDrawX();
      Double_t cur_maxx = gf->GetMaxDrawX();
      Double_t cur_miny = gf->GetMinDrawY();
      Double_t cur_maxy = gf->GetMaxDrawY();
      
      if(
         ( mind_x == - K_FinAn_double )
         ||
         ( mind_x != - K_FinAn_double && cur_minx != - K_FinAn_double && mind_x > cur_minx )
         ) 
        mind_x = cur_minx;
      
      if(
         ( maxd_x == K_FinAn_double )
         ||
         ( maxd_x != K_FinAn_double && cur_maxx != K_FinAn_double && maxd_x < cur_maxx )
         ) 
        maxd_x = cur_maxx;
      //
      if(
         ( mind_y == - K_FinAn_double )
         ||
         ( mind_y != - K_FinAn_double && cur_miny != - K_FinAn_double && mind_y > cur_miny )
         ) 
        mind_y = cur_miny;
      
      if(
         ( maxd_y == K_FinAn_double )
         ||
         ( maxd_y != K_FinAn_double && cur_maxy != K_FinAn_double && maxd_y < cur_maxy )
         ) 
        maxd_y = cur_maxy;

      //       cout << "------- en: " << en << endl;
      //       cout << "---> mind_x: " << mind_x << endl;
      //       cout << "---> maxd_x: " << maxd_x << endl;
      //       cout << "---> mind_y: " << mind_y << endl;
      //       cout << "---> maxd_y: " << maxd_y << endl;
      
      // limits of current graph
      Double_t lim_min_x = 0;
      Double_t lim_max_x = 0;
      Double_t lim_min_y = 0;
      Double_t lim_max_y = 0;
      GetHistogramLimits(gf->GetHistogram(),lim_min_x,lim_max_x,lim_min_y,lim_max_y);
      //
      if( lim_p_min_x !=  - K_FinAn_double && lim_min_x > lim_p_min_x ) lim_min_x = lim_p_min_x;
      else lim_p_min_x = lim_min_x;
      //
      if( lim_p_max_x !=  K_FinAn_double && lim_max_x < lim_p_max_x ) lim_max_x = lim_p_max_x;
      else lim_p_max_x = lim_max_x;
      //
      if( lim_p_min_y !=  - K_FinAn_double && lim_min_y > lim_p_min_y ) lim_min_y = lim_p_min_y;
      else lim_p_min_y = lim_min_y;
      //
      if( lim_p_max_y !=  K_FinAn_double && lim_max_y < lim_p_max_y ) lim_max_y = lim_p_max_y;
      else lim_p_max_y = lim_max_y;
      //
      //       cout << "---> lim_min_x: " << lim_min_x << endl;
      //       cout << "---> lim_max_x: " << lim_max_x << endl;
      //       cout << "---> lim_min_y: " << lim_min_y << endl;
      //       cout << "---> lim_max_y: " << lim_max_y << endl;
      
      if( mind_x != - K_FinAn_double ) minx = mind_x;
      else minx = lim_min_x;
      //
      if( maxd_x !=   K_FinAn_double ) maxx = maxd_x;
      else maxx = lim_max_x;
      //
      if( mind_y != - K_FinAn_double ) miny = mind_y;
      else miny = lim_min_y;
      //
      if( maxd_y !=  K_FinAn_double ) maxy = maxd_y;
      else maxy = lim_max_y;
      //}
  }
  gf = 0;
  //   cout << "---> minx: " << minx << endl;
  //   cout << "---> minx: " << maxx << endl;
  //   cout << "---> maxy: " << miny << endl;
  //   cout << "---> maxy: " << maxy << endl;
  
  if(at_least_one == kTRUE){
    //cout << "setting x: " << minx << " ; " << maxx << endl; 
    ax->SetRangeUser(minx,maxx);
    //cout << "setting y: " << miny << " ; " << maxy << endl; 
    ay->SetRangeUser(miny,maxy);
  }

  if(gPad){
    gPad->Modified();
    gPad->Update();
  }
  else{
    Warning("EvalAxisRange","NO PAD (gPad) !!!");
    return;
  }
}

//______________________________________
void TFndMultiGraph::SetTimeX(const Bool_t &time_x){
  
  TAxis *ax = GetXaxis();
  if(!ax ){
    Error("SetTimeX","NO HISTOGRAM!!!");
    return;
  }
  
  if(time_x){
    ax->SetTimeOffset(0);
    ax->SetTimeFormat("%d/%m/%y (%H:%M)");
    ax->SetTimeDisplay(1);
  }
  else ax->SetTimeDisplay(0);

  if(gPad){
    gPad->Modified();
    gPad->Update();
  }
  else{
    Warning("SetTimeX","NO PAD (gPad) !!!");
    return;
  }
}

//______________________________________
void TFndMultiGraph::Reset(){
  // remove all graphs and fitted functions
  
  if(fGraphs) fGraphs->Clear();
  if(fFunctions) fFunctions->Clear();  //Pointer to list of functions (fits and user)
  if(fHistogram){
    delete fHistogram;
    fHistogram = 0;
  }
}

//______________________________________
void TFndMultiGraph::DrawDefaults(Bool_t time_x){

  Draw("a");
  // ---
  SetTimeX(time_x);
  EvalAxisRange();
}

---