Month: September 2016

For example, assume you have a text file with four lines.

1 2.0
2 2.2
3 2.4
4 2.6

// code correct
{ 
  ifstream finput("owondata3.txt");
  const Int_t icount_max=16;
  Int_t icount=0;
  Double_t data1[icount_max], data2[icount_max];
  
  while(icount < icount_max) { 
    finput >> data1[icount] >> data2[icount];
    std::cout << icount << ", " << data1[icount] << ", " << data2[icount] << std::endl;
    if(finput.eof()) break;
    icount++;
  }
  std::cout << "icount = " << icount << std::endl;

  TCanvas *c1 = new TCanvas("c1","Test",200,100,800,600);
  TGraph *g = new TGraph(icount, data1, data2);
  g->SetMarkerStyle( 20 );
  g->SetMarkerSize( 2.0 );
  g->Draw("AP");
}

% root correct.cc 
0, 1, 2
1, 2, 2.2
2, 3, 2.4
3, 4, 2.6
4, 0, 0
icount = 4
0, 1, 2
1, 2, 2.2
2, 3, 2.4
3, 4, 2.6

// code wrong
{
  ifstream finput("owondata3.txt");
  const Int_t icount_max=16;
  Int_t icount=0;
  Double_t data1[icount_max], data2[icount_max];

  while(! finput.eof() ) {
    finput >> data1[icount] >> data2[icount];
    std::cout << icount << ", " << data1[icount] << ", " << data2[icount] << std::endl;
    icount++;
  }
  std::cout << "icount = " << icount << std::endl;

  for(int i=0;i<icount;i++) {
    std::cout << i << ", " << data1[i] << ", " << data2[i] << std::endl;
  }

  TCanvas *c1 = new TCanvas("c1","Wrong",200,100,800,600);
  TGraph *g = new TGraph(icount, data1, data2);
  g->SetMarkerStyle( 20 );
  g->SetMarkerSize( 2.0 );
  g->Draw("AP");
}

% root wrong.cc 
0, 1, 2
1, 2, 2.2
2, 3, 2.4
3, 4, 2.6
4, 0, 0
icount = 5
0, 1, 2
1, 2, 2.2
2, 3, 2.4
3, 4, 2.6
4, 0, 0

If you wish to avoid using AWK one-liners, doing the same thing in your ROOT macro, the code will be:

% cat owondata.txt | awk 'NR>8 {print $1, $3}' >owondata_ch1.txt
% cat owondata.txt | awk 'NR>8 {print $1, $4}' >owondata_ch2.txt

{
  ifstream finput("owondata.txt"); // read the original file without using AWK one-liners
  Int_t nskip=8;
  std::string s;

  for(int i=0;i<nskip;i++) { // skip the first eight lines
    getline(finput, s);
  }

  const Int_t icount_max=8192;
  Int_t icount=0;
  Double_t dummy, data1[icount_max], data2[icount_max], data3[icount_max]; // save $1, $3, and $4
  while(icount < icount_max) {
    finput >> data1[icount] >> dummy >> data2[icount] >> data3[icount];
    if(finput.eof()) break;
    icount++;
  }

  TCanvas *c1 = new TCanvas("c1","Test",200,100,800,600);
  TGraph *g = new TGraph(icount, data1, data2); // ch1 data
  g->SetMarkerStyle( 20 ); 
  g->SetMarkerSize( 0.5 );
  g->Draw("AP");
  TF1 *f1 = new TF1("f1", "[0]*sin([1]*x+[2])-[3]");
  f1->SetParameter(0, 2000.0);
  f1->SetParameter(1, 0.022);
  f1->SetParameter(2, 0.0);
  f1->SetParameter(3, 0.0);
  f1->SetLineColor(kRed);
  g->Fit(f1);

  TGraph *h = new TGraph(icount, data1, data3); // ch2 data
  h->SetMarkerStyle( 24 ); 
  h->SetMarkerSize( 0.5 );
  h->Draw("P");
  TF1 *f2 = new TF1("f2", "[0]*sin([1]*x+[2])-[3]");
  f2->SetParameter(0, 2000.0);
  f2->SetParameter(1, 0.022);
  f2->SetParameter(2, 0.0);
  f2->SetParameter(3, 0.0);
  f2->SetLineColor(kYellow);
  h->Fit(f2);

  double amp, phase;
  amp   = f2->GetParameter(0) / f1->GetParameter(0);
  phase = f2->GetParameter(2) - f1->GetParameter(2);
  std::cout << amp << ", " << phase << std::endl;

  TComplex v1, v2, v3, Z, z50;
  v1  = TComplex(1.0, 0.0);
  v2  = TComplex( amp*TMath::Cos(phase), amp*TMath::Sin(phase) );
  v3  = 2.0*v1 - v2;
  z   = v2/v3;
  z50 = 50.0*z;
  std::cout << v1 << ", " << v2 << ", " << v3 << ", " << z << ", " << z50 << std::endl;

  TComplex rho;
  double vswr;
  rho  = (z-1.0)/(z+1.0);
  vswr = (1.0+TComplex::Abs(rho)) / (1.0-TComplex::Abs(rho));
  std::cout << rho << ", " << vswr << std::endl;
}

Note that the following code does not work properly unless you decrement icount out of the while loop.

while(! finput.eof() ) }
  finput >> ...
  icount++;
}

ROOT has a built in C++ interpreter called Cling. One example of using Cling is:

% root
root [0] TF1 f1("f1", "sin(x)/x", -10.0, 10.0)
root [1] f1.Draw()

Note that the terminating “;” is not required at the end of each line.

Or you can write a ROOT macro, which is a collection of lines.

// file name = myprog1.C
void myprog1(){
   TCanvas *c1 = new TCanvas("c1" ,"Test" ,0 ,0 ,600 ,400) ;
   c1->SetGrid( ) ;
   TF1 *f1 = new TF1("f1", "sin(x)/x", -10.0, 10.0);
   f1->Draw();
   c1->Update();
}

You can execute your macros either by:

% root myprog1.C
// or
% root
root [0] .x myprog1.C

Your macros can also be compiled by adding some “dressing code”.

https://root.cern.ch/root/htmldoc/guides/primer/ROOTPrimer.html#interpretation-and-compilation

// file name = myprog2.C

//include some header files, not necessary for Cling.
#include "TApplication.h"
#include "TROOT.h"
#include "TCanvas.h"
#include "TF1.h"
using namespace std;

void myprog2() {
  TCanvas *c1 = new TCanvas("c1", "Test", 0, 0, 600, 400);
  c1->SetGrid();
  TF1 *f1 = new TF1("f1", "sin(x)/x", -10.0, 10.0);
  f1->Draw();
  c1->Update();
}

void StandaloneApplication(int argc, char** argv) {
  myprog2();
}

int main (int argc, char** argv) {
  TApplication app("ROOT Application", &argc, argv);
  StandaloneApplication(app.Argc(), app.Argv());
  app.Run();
  return 0;
}

% g++ -o myprog2 myprog2.C `root-config --cflags --libs`
./myprog2

Finally, you can use a set of bindings called PyROOTto interface to Python.

# file name = myprog3.py
from ROOT import TCanvas, TF1
c1=TCanvas("c1" ,"Test" ,0 ,0 ,600 ,400) 
c1.SetGrid ()
f1=TF1("f1", "sin(x)/x", -10.0, 10.0)
f1.Draw()
c1.Update()
raw_input('Press <ret> to end -> ')

% python myprog3.py