///////////////////////////////////////////////////////////////////
//////// Go4 GUI example script fft.C
// J.Adamczewski, gsi, 30 May 2012
// NOTE: to be run in Go4 GUI local command line only!
// NEVER call this script in remote analysis process!!!
/////// Functionality:
// perfroms fft on histogram of name1 using the option as explained in root TVirtualFFT:FFT
/////// Usage:
// The draw flag switches if the results are displayed each time this macro is called
// if display is switched off, the result histogram is just updated in browser and existing displays
///////
Bool_t fft(const char* name1, Option_t* opt = "R2C M", Bool_t draw=kTRUE)
{
if(TGo4AbstractInterface::Instance()==0 || go4!=TGo4AbstractInterface::Instance()) {
std::cout <<"FATAL: Go4 gui macro executed outside Go4 GUI!! returning." << std::endl;
return kFALSE;
}
TString newname;
TString fullname1 = go4->FindItem(name1);
TObject* ob1 = go4->GetObject(fullname1,1000); // 1000=timeout to get object from analysis in ms
if ((ob1==0) || !ob1->InheritsFrom("TH1")) {
std::cout <<"fft could not get histogram "<<fullname1 << std::endl;
return kFALSE;
}
if(ob1->InheritsFrom("TH2") || ob1->InheritsFrom("TH3")){ // 2d
std::cout <<"fft does not support 2d/3d histogram "<<fullname1 << std::endl;
return kFALSE;
}
TH1* his1=(TH1*)ob1;
TString n1=his1->GetName();
TString t1=his1->GetTitle();
newname.Form("_fft_%s",opt);
TString finalname = n1+newname;
TString finaltitle = t1+newname;
// do fft here:
Int_t N = his1->GetNbinsX();
TH1D* result = new TH1D(finalname, finaltitle,N,0,N);
result->SetName(finalname);
result->SetTitle(finaltitle);
result->Reset("");
Double_t *in = new Double_t[N];
// since we do not know type of input histo, we copy contents to Double array:
for(Int_t ix=0; ix<N;++ix)
{
in[ix]=his1->GetBinContent(ix+1);
}
TVirtualFFT *thefft = TVirtualFFT::FFT(1, &N, opt);
thefft->SetPoints(in);
thefft->Transform();
Double_t re, im;
for (Int_t i=0; i<N; i++) {
thefft->GetPointComplex(i, re, im);
result->SetBinContent(i+1,TMath::Sqrt(re*re + im*im));
}
result->SetDirectory(0);
TString rname = go4->SaveToMemory("FFT", result, kTRUE);
std::cout<< "Saved result histogram to " << rname.Data() <<std::endl;
if(draw){
ViewPanelHandle vpanel = go4->StartViewPanel();
go4->DrawItem(rname, vpanel);
}
return kTRUE;
}
void PlotVectorPotential( const TString &sim, Int_t timestep, const TString &options="") {
#ifdef __CINT__
gSystem->Load("libptools.so");
#endif
PData *pData = PData::Get(sim.Data());
if(pData->isHiPACE()) {
delete pData; pData = NULL;
pData = PDataHiP::Get(sim.Data());
}
pData->LoadFileNames(timestep);
if(!pData->IsInit()) return;
PGlobals::Initialize();
TString opt = options;
// Open snapshot file and get the histograms
TString filename;
filename = Form("./%s/Plots/Snapshots/Snapshot-%s_%i.root",sim.Data(),sim.Data(),timestep);
TFile *ifile = (TFile*) gROOT->GetListOfFiles()->FindObject(filename.Data());
if (!ifile) ifile = new TFile(filename,"READ");
ifile->cd();
// Time in OU
Double_t Time = pData->GetRealTime();
cout << Form(" Getting histos..." );
// Electron density (plasma)
char hName[36];
sprintf(hName,"hDen2D_0");
TH2F *hDen2D = (TH2F*) ifile->Get(hName);
// Electron density species 2 (if any)
sprintf(hName,"hDen2D_1");
TH2F *hDen2D_1 = (TH2F*) ifile->Get(hName);
if(hDen2D_1)
hDen2D->Add(hDen2D_1,1);
// Electron density species 3 (if any)
sprintf(hName,"hDen2D_2");
TH2F *hDen2D_2 = (TH2F*) ifile->Get(hName);
if(hDen2D_2)
hDen2D->Add(hDen2D_2,1);
cout << Form(" done!" ) << endl;
// Get the sliced 1D histograms
Int_t NBinsZ = hDen2D->GetXaxis()->GetNbins();
Float_t zmin = hDen2D->GetXaxis()->GetBinLowEdge(1);
Float_t zmax = hDen2D->GetXaxis()->GetBinUpEdge(NBinsZ);
Float_t zrange = zmax-zmin;
Int_t NBinsX = hDen2D->GetYaxis()->GetNbins();
Float_t xmin = hDen2D->GetYaxis()->GetBinLowEdge(1);
Float_t xmax = hDen2D->GetYaxis()->GetBinUpEdge(NBinsX);
Float_t xrange = xmax-xmin;
// cout << Form(" Creating 2D histos..." );
// cout << Form(" done!" ) << endl;
cout << Form(" Allocating array with real data..." );
Int_t dims[2] = {NBinsZ,NBinsX};
Double_t *data = new Double_t[NBinsZ*NBinsX];
// TVirtualFFT::SetTransform(0);
cout << Form(" done!" ) << endl;
cout << Form(" Filling data aray..." );
for(Int_t i=0; i<NBinsZ; i++) {
for(Int_t j=0; j<NBinsX; j++) {
Int_t index = i * NBinsX + j;
data[index] = hDen2D->GetBinContent(i+1,j+1);
// substract ion background
data[index] -= 1;
}
}
cout << Form(" done!" ) << endl;
cout << Form(" Fourier transform ..." );
// TH2F *hFFTREb = new TH2F("hFFTREb","",NBinsZ,kzmin,kzmax,NBinsX,kxmin,kxmax);
// TH2F *hFFTIMb = new TH2F("hFFTIMb","",NBinsZ,kzmin,kzmax,NBinsX,kxmin,kxmax);
// TH2F *hFFTREb = new TH2F("hFFTREb","",NBinsZ,0.,NBinsZ,NBinsX,0.,NBinsX);
// TH2F *hFFTIMb = new TH2F("hFFTIMb","",NBinsZ,0.,NBinsZ,NBinsX,0.,NBinsX);
// TH2F *hFFTRE = 0;
// hFFTRE = (TH2F*) TH1::TransformHisto(fft, hFFTRE, "RE");
// hFFTRE->SetName("hFFTRE");
// TH2F *hFFTIM = 0;
// hFFTIM = (TH2F*) TH1::TransformHisto(fft, hFFTIM, "IM");
// hFFTIM->SetName("hFFTIM");
TVirtualFFT *fft = TVirtualFFT::FFT(2, dims, "R2C ES K");
fft->SetPoints(data);
fft->Transform();
cout << Form(" done!" ) << endl;
cout << Form(" Solving equation for potential in fourier space" ) << endl;
// \phi(kz,kx) = 1/(kz^2 + kx^2)
fft->GetPoints(data);
for(Int_t i=0; i<dims[0]; i++) {
for(Int_t j=0; j<(dims[1]/2+1); j++) {
Int_t index = 2 * (i * (dims[1]/2+1) + j);
Float_t kz;
if(i<dims[0]/2)
kz = TMath::Pi() * (i+0.5) / zrange;
else
kz = -TMath::Pi() * (dims[0]-i+0.5) / zrange;
Float_t kx = TMath::TwoPi() * (j+0.5) / xrange;
Float_t k2 = kx*kx + kz*kz;
data[index] /= k2;
data[index+1] /= k2;
}
}
cout << Form(" done!" ) << endl;
cout << Form(" Inverse Fourier transform ..." );
// backward transform:
TVirtualFFT *fft_back = TVirtualFFT::FFT(2, dims, "C2R ES K");
fft_back->SetPoints(data);
fft_back->Transform();
cout << Form(" done!" ) << endl;
Double_t *re_back = fft_back->GetPointsReal();
TH2F *hPhi2D = new TH2F("hPhi2D","",NBinsZ,zmin,zmax,NBinsX,xmin,xmax);
TH2F *hE2D_1_ifft = new TH2F("hE2D_1_ifft","",NBinsZ,zmin,zmax,NBinsX,xmin,xmax);
Double_t dx = hPhi2D->GetYaxis()->GetBinWidth(1);
for(Int_t i=0; i<NBinsZ; i++) {
for(Int_t j=0; j<NBinsX; j++) {
Int_t index = i * NBinsX + j;
hPhi2D->SetBinContent(i+1,j+1,re_back[index]);
Double_t der = 0.;
if(j>2 && j<=NBinsX-2) {
Int_t indjp1 = i * NBinsX + (j+1);
Int_t indjp2 = i * NBinsX + (j+2);
Int_t indjm1 = i * NBinsX + (j-1);
Int_t indjm2 = i * NBinsX + (j-2);
der = ( 4.0 / 3.0 * (re_back[indjp1] - re_back[indjm1]) / (2.0 * dx)
- 1.0 / 3.0 * (re_back[indjp2] - re_back[indjm2]) / (4.0 * dx) );
}
hE2D_1_ifft->SetBinContent(i+1,j+1,der);
}
}
hPhi2D->Scale(1.0/(NBinsZ*NBinsX));
hE2D_1_ifft->Scale(1.0/(NBinsZ*NBinsX));
TH2F *hE2D_0_ifft = new TH2F("hE2D_0_ifft","",NBinsZ,zmin,zmax,NBinsX,xmin,xmax);
Double_t dz = hPhi2D->GetXaxis()->GetBinWidth(1);
for(Int_t j=0; j<NBinsX; j++) {
for(Int_t i=0; i<NBinsZ; i++) {
Double_t der = 0.;
if(i>2 && j<=NBinsZ-2) {
Int_t indip1 = (i+1) * NBinsX + j;
Int_t indip2 = (i+2) * NBinsX + j;
Int_t indim1 = (i-1) * NBinsX + j;
Int_t indim2 = (i-2) * NBinsX + j;
der = ( 4.0 / 3.0 * (re_back[indip1] - re_back[indim1]) / (2.0 * dz)
- 1.0 / 3.0 * (re_back[indip2] - re_back[indim2]) / (4.0 * dz) );
}
hE2D_0_ifft->SetBinContent(i+1,j+1,der);
}
}
hE2D_0_ifft->Scale(1.0/(NBinsZ*NBinsX));
// TH2F *hPhi2D = 0;
// hPhi2D = (TH2F*) TH1::TransformHisto(fft_back, hPhi2D, "RE");
// hPhi2D->SetName("hPhi2D");
}
void analysis() {
Int_t nbins = 800;
Int_t j;
char name[20];
char title[100];
TH1F *HistoEvent[2214];
for (Int_t z=0;z<2214;z++) {
sprintf(name,"HistoEvent%d",z-1);
sprintf(title,"Event%d Histo", z-1);
HistoEvent[z] = new TH1F(name,title,nbins, -0.1, 159.9);
}
TH1F *NewHistoEvent[2214];
for (Int_t z=0;z<2214;z++) {
sprintf(name,"NewHistoEvent%d",z-1);
sprintf(title,"Event%d Histo", z-1);
NewHistoEvent[z] = new TH1F(name,title,nbins, -0.1, 159.9);
}
TH1F *NewHistoEventFFT[2214];
for (Int_t z=0;z<2214;z++) {
sprintf(name,"NewHistoEventFFT%d",z-1);
sprintf(title,"Event%d Histo", z-1);
NewHistoEventFFT[z] = new TH1F(name,title,nbins, 0, 5);
}
Double_t mean;
Double_t rms;
Double_t meansum = 0;
Double_t count = 0;
Double_t meanrms = 0;
TFile f("/home/marko/H4Analysis/ntuples/analysis_4443.root"); //ntuple generated by H4Analysis tool
TFile f1("/home/marko/H4Analysis/ntuples/analysis_3905.root");
TFile f2("/home/marko/Desktop/TB Timing Res/NormalizedSignalNoise.root", "read");
TH1F* BestSignal = (TH1F*) f2.Get("BetterSignal");
TFile outputfile("myoutput.root", "recreate");
TCanvas* TimeandFreq = new TCanvas("TimeandFreq","Time and Frequency",1500,900);
TCanvas* Freq = new TCanvas("Freq","Frequency",800,1200);
TCanvas* TimeSignal = new TCanvas("TimeSignal","Pure Signal",800,1200);
TimeandFreq->Divide(2,2);
TTree* h4 = (TTree*) f.Get("h4");
TTree* h4_2 = (TTree*) f1.Get("h4");
TString plot;
TString cut;
TH2F* WavePulse = new TH2F ("WavePulse", "Wave Pulse", nbins, -0.1, 159.9, 850, -50, 800);
TH2F* NoisePulse = new TH2F ("NoisePulse", "Noise", nbins, -0.1, 159.9, 100, -50, 50);
TH1F* PulseTime = new TH1F ("PulseTime", "Original Wave Pulse", nbins, -0.1, 159.9); //nanoseconds
TH2F* TempHisto = new TH2F ("TempHisto", "Temp Histo", nbins, -0.1, 159.9, 1000, -15, 15); //nanoseconds
h4->Draw("WF_val:WF_time>>WavePulse", "WF_ch==2 && event==1 && spill==1");
h4_2->Draw("WF_val:WF_time>>NoisePulse","WF_ch==APD1 && amp_max[APD3]<25 && b_rms[APD3]<5. && charge_tot[APD3]<20000 && amp_max[APD5]<25 && b_rms[APD5]<5. && amp_max[APD6]<25 && b_rms[APD6]<5. && amp_max[APD4]<25 && b_rms[APD4]<5. && amp_max[SiPM1]<20 && amp_max[SiPM2]<20 && amp_max[APD1]<40 && amp_max[APD2]<40 && b_rms[APD1]<5. && b_rms[APD2]<5. && WF_time<160");
for (Int_t i=0; i<nbins; i++) {
for (Int_t k=0; k<4096; k++) {
if (WavePulse->GetBinContent(i+1, k) != 0) {
PulseTime->SetBinContent(i+1,k-50);
}
}
}
TH1F *NoiseTime = new TH1F ("NoiseTime", "Noise", nbins, -0.1, 159.9);
for (Int_t i=0; i<nbins; i++) {
for (Int_t k=0; k<4096; k++) {
if (NoisePulse->GetBinContent(i+1, k) != 0) {
NoiseTime->SetBinContent(i+1,k-62.9087);
}
}
}
//TH1F* NormNoiseFFT = new TH1F ("NormNoiseFFT", "Normalized Noise FFT", nbins, 0, 5);
//TStopwatch t;
//t.Start(); //1 hour runtime
//for (j=10;j<20;j++) {
// plot = "WF_val:WF_time>>TempHisto";
// cut = "WF_ch==APD1 && amp_max[APD3]<25 && b_rms[APD3]<5. && charge_tot[APD3]<20000 && amp_max[APD5]<25 && b_rms[APD5]<5. && amp_max[APD6]<25 && b_rms[APD6]<5. && amp_max[APD4]<25 && b_rms[APD4]<5. && amp_max[SiPM1]<20 && amp_max[SiPM2]<20 && amp_max[APD1]<40 && amp_max[APD2]<40 && b_rms[APD1]<5. && b_rms[APD2]<5. && WF_time<160 && event==";
// cut += j;
// h4_2->Draw(plot, cut, "goff");
// if (TempHisto->GetMaximum() == 0) {
// delete HistoEvent[j+1];
// continue;
// }
// for (Int_t i=0; i<nbins; i++) {
// for (Int_t k=0; k<1000; k++) {
// if (TempHisto->GetBinContent(i+1, k) != 0) {
// HistoEvent[j+1]->SetBinContent(i+1,k*0.03-15);
// }
// }
// }
// mean = TempHisto->GetMean(2);
// rms = TempHisto->GetRMS(2);
// for (Int_t q=0;q<nbins;q++) {
// NewHistoEvent[j+1]->SetBinContent(q+1, HistoEvent[j+1]->GetBinContent(q+1)-mean);
// }
// NewHistoEvent[j+1]->Scale(1/rms);
// NewHistoEvent[j+1]->FFT(NewHistoEventFFT[j+1], "MAG");
// NormNoiseFFT->Add(NormNoiseFFT, NewHistoEventFFT[j+1]);
// TempHisto->Write();
// NewHistoEvent[j+1]->Write();
// NewHistoEventFFT[j+1]->Write();
// cout << "Event " << j << ", Mean = " << mean << ", RMS = " << rms << endl;
// count += 1;
//}
//NormNoiseFFT->Scale(1/count);
//NormNoiseFFT->Write();
//t.Stop();
//t.Print();
new TFile("/home/marko/H4Analysis/ntuples/analysis_4443.root"); // ignore this reloading of the same file, it is required or else the plots do not show up (when I tried)
TimeandFreq->cd(1);
PulseTime->GetXaxis()->SetTitle("Time (ns)");
PulseTime->GetYaxis()->SetTitle("Amplitude");
PulseTime->DrawClone(); //Wave Pulse in Time domain
TimeandFreq->cd(2);
TH1F* PulseFreq = new TH1F ("PulseFreq", "Pulse FFT", nbins, 0, 5);
TH1F* PulsePhase = new TH1F ("PulsePhase", "Pulse Phase", nbins, -0.1, 799.9);
PulseTime->FFT(PulseFreq, "MAG");
PulseTime->FFT(PulsePhase, "PH");
PulseFreq->SetLineColor(kRed);
PulseFreq->GetXaxis()->SetTitle("Frequency (GHz)");
PulseFreq->GetYaxis()->SetTitle("Amplitude");
PulseFreq->DrawClone(); //Wave Pulse in Frequency domain
gPad->SetLogy();
TimeandFreq->cd(3);
NoiseTime->GetXaxis()->SetTitle("Time (ns)");
NoiseTime->GetYaxis()->SetTitle("Amplitude");
NoiseTime->DrawClone(); // Noise from pedestal in Time domain
TimeandFreq->cd(4);
TH1F* NoiseFreq = new TH1F ("NoiseFreq", "Noise FFT", nbins, 0, 5);
NoiseTime->FFT(NoiseFreq, "MAG");
NoiseFreq->GetXaxis()->SetTitle("Frequency (GHz)");
NoiseFreq->GetYaxis()->SetTitle("Amplitude");
NoiseFreq->Draw(); // Noise from pedestal in Frequency domain
gPad->SetLogy();
Freq->Divide(1,3);
Freq->cd(1);
PulseFreq->DrawClone();
gPad->SetLogy();
Freq->cd(2);
NoiseFreq->DrawClone();
gPad->SetLogy();
Freq->cd(3);
PulseFreq->SetTitle("Pulse and Noise FFT Comparison");
PulseFreq->Draw();
NoiseFreq->Draw("same");
gPad->SetLogy();
TH1F* UnscaledSignalFreq = new TH1F ("UnscaledSignalFreq", "Unscaled Signal Frequency", nbins, -0.1, 799.9);
for (Int_t l=0; l<nbins; l++) {
UnscaledSignalFreq->SetBinContent(l+1, (PulseFreq->GetBinContent(l+1)-NoiseFreq->GetBinContent(l+1))/PulseFreq->GetBinContent(l+1));
}
TH1F* SignalFreq = new TH1F ("SignalFreq", "Signal Frequency", nbins, 0, 799.9);
for (Int_t m=0; m<nbins; m++) {
SignalFreq->SetBinContent(m+1, UnscaledSignalFreq->GetBinContent(m+1)*PulseFreq->GetBinContent(m+1));
}
Double_t *re_full = new Double_t[nbins];
Double_t *im_full = new Double_t[nbins];
for (Int_t n=0; n<nbins; n++) {
(re_full)[n]=(SignalFreq->GetBinContent(n+1)*cos(PulsePhase->GetBinContent(n+1)));
(im_full)[n]=(SignalFreq->GetBinContent(n+1)*sin(PulsePhase->GetBinContent(n+1)));
}
TVirtualFFT *invFFT = TVirtualFFT::FFT(1, &nbins, "C2R M K");
invFFT->SetPointsComplex(re_full, im_full);
invFFT->Transform();
TH1 *Signal = 0;
Signal = TH1::TransformHisto(invFFT,Signal,"Re");
Signal->SetTitle("Recovered Signal 'S'");
TH1F* BetterSignal = new TH1F ("BetterSignal", "Recovered Signal", nbins, -0.1, 159.9);
for (Int_t p=0; p<nbins; p++) {
BetterSignal->SetBinContent(p+1, Signal->GetBinContent(p+1)/nbins);
}
TimeSignal->Divide(1,2);
TimeSignal->cd(1);
PulseTime->DrawClone(); //Original Wave Pulse
TimeSignal->cd(2);
BetterSignal->GetXaxis()->SetTitle("Time (ns)");
BetterSignal->GetYaxis()->SetTitle("Amplitude");
BetterSignal->SetLineColor(kRed);
//BetterSignal->Draw(); // Recovered Wave Pulse with decreased contribution from background noise
BestSignal->SetLineColor(kGreen);
BestSignal->DrawClone("same");
PulseTime->DrawClone("same");
}
void decon_ind(Int_t chan = 221){
TFile *file = new TFile("Run_00009188.root");
TH2* h1 = (TH2*)file->Get(Form("Ind_%d",chan));
TH2* h3 = (TH2*)h1->Clone("h3");
TH2* h4 = (TH2*)h1->Clone("h4");
h3->Reset();
h4->Reset();
gStyle->SetOptStat(0);
TCanvas *c1 = new TCanvas("c1","c1",800,800);
c1->Divide(2,2);
c1->cd(1);
h1->Draw("COLZ");
h1->GetZaxis()->SetRangeUser(-80,80);
h1->GetXaxis()->SetRangeUser(0,3000);
h1->SetTitle("Original Induction");
h3->SetTitle("Noise Removed Induction");
Int_t max_bin = h1->GetMaximumBin();
Float_t max = h1->GetBinContent(max_bin);
Int_t min_bin = h1->GetMinimumBin();
Float_t min = h1->GetBinContent(min_bin);
TH1F *h2 = new TH1F("h2","h2",Int_t(max - min+2), min-1, max+1);
//cout << h1->GetXaxis()->GetNbins() << " " << h1->GetYaxis()->GetNbins() << endl;
for (Int_t i=0;i!=h1->GetXaxis()->GetNbins();i++){
h2->Reset();
for (Int_t j=0;j!=h1->GetYaxis()->GetNbins();j++){
h2->Fill(h1->GetBinContent(i,j));
}
Double_t xq = 0.5;
Double_t par[10];
h2->GetQuantiles(1,&par[0],&xq);
for (Int_t j=0;j!=h1->GetYaxis()->GetNbins();j++){
h3->SetBinContent(i,j,h1->GetBinContent(i,j)-par[0]);
}
//cout << par[0] << endl;
}
c1->cd(2);
h3->Draw("COLZ");
h3->GetXaxis()->SetRangeUser(0,3000);
// do deconvolution for every channel ...
c1->cd(3);
TFile *file1 = new TFile("ave_res.root");
TH1F *hva = (TH1F*)file1->Get("hu");
TGraph *gva = new TGraph();
for (Int_t i=0;i!=hva->GetNbinsX();i++){
Double_t x = hva->GetBinCenter(i+1);
Double_t y = hva->GetBinContent(i+1) * (-1);
gva->SetPoint(i,x,y);
}
TH1F *h2t = new TH1F("h2t","h2t",h1->GetXaxis()->GetNbins(),0,h1->GetXaxis()->GetNbins());
TH1F *h2r = (TH1F*)h2t->Clone("h2r");
h2r->Reset();
for (Int_t i=0;i!=h2r->GetNbinsX();i++){
Double_t x = h2r->GetBinCenter(i+1)/2.-50;
h2r->SetBinContent(i+1,gva->Eval(x));
}
TF1 *filter_v = new TF1("filter_v","(x>0.0)*gaus*exp(-0.5*pow(x/[3],[4]))");
double par1[5]={1.74/0.941034, 1.46, 1.33, 0.23, 4.89};
filter_v->SetParameters(par1);
TVirtualFFT::SetTransform(0);
TH1 *hmr = 0;
TH1 *hpr = 0;
Int_t n = 8192;
TVirtualFFT *ifft = TVirtualFFT::FFT(1,&n,"C2R M K");
Double_t value_re[8192];
Double_t value_im[8192];
TH1 *fb = 0;
TH1 *hmv = 0;
TH1 *hpv = 0;
for (Int_t k=0;k!=h1->GetYaxis()->GetNbins();k++){
// for (Int_t k=33;k!=33+1;k++){
h2t->Reset();
for (Int_t i=0;i!=8192;i++){
float content = h3->GetBinContent(i+1,k+1);
h2t->SetBinContent(i+1,content);
}
h2t->Draw();
cout << h2t->Integral(500,1500) << endl;
//cout << max << " " << min << endl;
hmr = 0;
hpr = 0;
hmr = h2r->FFT(hmr,"MAG");
hpr = h2r->FFT(hpr,"PH");
hmv = 0;
hpv = 0;
hmv = h2t->FFT(hmv,"MAG");
hpv = h2t->FFT(hpv,"PH");
for (Int_t j=0;j!=8192;j++){
Double_t freq;
if ( j < 8192/2.){
freq = j/8192.*2.;
}else{
freq = (8192-j)/8192.*2.;
}
Double_t rho;
if (hmr->GetBinContent(j+1)!=0){
rho = hmv->GetBinContent(j+1) / hmr->GetBinContent(j+1)*filter_v->Eval(freq);
}else{
rho = 0;
}
Double_t phi = hpv->GetBinContent(j+1) - hpr->GetBinContent(j+1);
value_re[j] = rho*cos(phi)/8192.;
value_im[j] = rho*sin(phi)/8192.;
}
ifft->SetPointsComplex(value_re,value_im);
ifft->Transform();
fb = 0;
fb = TH1::TransformHisto(ifft,fb,"Re");
Double_t sum = 0;
Double_t sum1 = 0;
for (Int_t i=5000;i!=8000;i++){
sum += fb->GetBinContent(i+1);
sum1 += 1;
}
for (Int_t i=0;i!=8192;i++){
Int_t binnum = i+1+104;
if (binnum > 8192) binnum -=8192;
h4->SetBinContent(binnum,k+1,fb->GetBinContent(i+1)-sum/sum1);
}
}
h3->GetZaxis()->SetRangeUser(0,100);
c1->cd(3);
h4->RebinX(4);
for (Int_t i=0;i!=h4->GetXaxis()->GetNbins();i++){
for (Int_t j=0;j!=h4->GetYaxis()->GetNbins();j++){
Double_t content1 = h4->GetBinContent(i+1,j+1);
// if (content1 <1)
// h4->SetBinContent(i+1,j+1,1);
}
}
h4->Draw("COLZ");
h4->GetZaxis()->SetRangeUser(0,30);
h4->GetXaxis()->SetRangeUser(0,3000);
c1->cd(4);
TH2 *h5 = (TH2*)file->Get(Form("Col_%d",chan));
h5->Draw("COLZ");
h5->GetZaxis()->SetRangeUser(0,300);
h5->GetXaxis()->SetRangeUser(0,3000);
c1->cd(2);
for (Int_t i=0;i!=h3->GetXaxis()->GetNbins();i++){
for (Int_t j=0;j!=h3->GetYaxis()->GetNbins();j++){
Double_t content1 = h3->GetBinContent(i+1,j+1);
content1 = fabs(content1);
h3->SetBinContent(i+1,j+1,content1);
}
}
h3->Draw("COLZ");
h4->SetTitle("Deconvoluted Induction");
h5->SetTitle("Collection Raw");
// c1->cd(1);
// h2r->Draw();
// c1->cd(4);
// Double_t sum = 0;
// Double_t sum1 = 0;
// for (Int_t i=4000;i!=7000;i++){
// sum += fb->GetBinContent(i+1);
// sum1 += 1;
// }
// TH1F *h2k = (TH1F*)h2t->Clone("h2k");
// for (Int_t j=0;j!=8192;j++){
// h2k->SetBinContent(j+1,fb->GetBinContent(j+1)-sum/sum1);
// }
// h2k->Rebin(4);
// h2k->Draw();
}
