QGCalibrationWindow.cc

Go to the documentation of this file.

#include "QGCalibrationWindow.hh"
#include <iostream>
#include <list>
#include <string>
#include <fstream>
#include "QGCalibrationPeakFrame.hh"
#include "QGHistogram.hh"
#include "QGPlot.hh"
#include "QGSessionHandler.hh"
#include "TGButton.h"
#include "TGComboBox.h"
#include "TGFrame.h"
#include "TGLabel.h"
#include "TString.h"
 
ClassImp(QGCalibrationWindow)
 
using std::cout;
using std::endl;
using std::list;
using std::map;
using std::string;
using std::vector;
 
QGCalibrationWindow::QGCalibrationWindow(const TGWindow *p, UInt_t w, UInt_t h) :
QGWindow(p, w, h), fCurrentHistogramName("")
{
    SetWindowName("Calibration Window");
    
    vector<string> instructions_above_histograms;
    instructions_above_histograms.push_back("Select a channel from the list to calibrate and click \"Draw\"");
    
    for ( vector<string>::const_iterator iter = instructions_above_histograms.begin();
          iter != instructions_above_histograms.end();
          ++iter ) {
        TGLabel *instruction = new TGLabel(this, iter->c_str());
        AddFrame(instruction, new TGLayoutHints(kLHintsCenterX, 5, 5, 1, 0));
    }
    
    fHistogramFrame = new TGHorizontalFrame(this);
    
    fHistogramDropDownBox = new TGComboBox(fHistogramFrame);
    fHistogramFrame->AddFrame(fHistogramDropDownBox, new TGLayoutHints(kLHintsCenterY, 0, 0, 0, 0));
    SetUpHistograms();
    fHistogramDropDownBox->Resize(200, 25);
    fHistogramDropDownBox->Connect("Selected(const char*)", "QGCalibrationWindow", this, "HandleHistogramDropDownBox(const char*)");
    
    fDrawButton = new TGTextButton(fHistogramFrame, "Draw");
    fDrawButton->Connect("Clicked()", "QGCalibrationWindow", this, "HandleDrawButton()");
    fHistogramFrame->AddFrame(fDrawButton, new TGLayoutHints(kLHintsCenterY, 5, 0, 0, 0));
    
    AddFrame(fHistogramFrame, new TGLayoutHints(kLHintsCenterX, 0, 0, 5, 4));
    
    vector<string> instructions_above_peaks;
    instructions_above_peaks.push_back("Zoom in to a window containing each peak and click\"Set\" to record the");
         instructions_above_peaks.push_back("max and min of the window.  When you are finished with");
         instructions_above_peaks.push_back(" all the peaks and channels, click \"Save\" to produce the output file.");
    
    for ( vector<string>::const_iterator iter = instructions_above_peaks.begin();
          iter != instructions_above_peaks.end();
          ++iter ) {
        TGLabel *instruction = new TGLabel(this, iter->c_str());
        AddFrame(instruction, new TGLayoutHints(kLHintsCenterX, 5, 5, 1, 0));
    }
    
    fSaveButton = new TGTextButton(this, "Save");
    AddFrame(fSaveButton, new TGLayoutHints(kLHintsCenterX, 0, 0, 5, 5));
    fSaveButton->Connect("Clicked()", "QGCalibrationWindow", this, "HandleSaveButton()");
    
    Resize(GetDefaultSize());
    MapSubwindows();
    Resize(w, h);
    MapWindow();
}
 
QGCalibrationWindow::~QGCalibrationWindow()
{
}
 
void QGCalibrationWindow::AddPeak(Double_t energy)
{
    RemoveFrame(fSaveButton);
 
    QGCalibrationPeakFrame *calibrationPeakFrame = new QGCalibrationPeakFrame(this);
    fCalibrationPeakFrames.push_back(calibrationPeakFrame);
    calibrationPeakFrame->SetEnergy(energy);
    AddFrame(calibrationPeakFrame, new TGLayoutHints(kLHintsLeft, 0, 5, 5, 0));
    
    AddFrame(fSaveButton, new TGLayoutHints(kLHintsCenterX, 0, 0, 5, 5));
    
    MapSubwindows();
    Resize();
}
 
void QGCalibrationWindow::Clear(Option_t* opt)
{
    vector<QGCalibrationPeakFrame*>::const_iterator peakIter;
    for (peakIter = fCalibrationPeakFrames.begin(); peakIter != fCalibrationPeakFrames.end(); ++peakIter) {
        (*peakIter)->Clear(opt);
    }
}
 
QGPlot *QGCalibrationWindow::GetCurrentPlot() const
{
    QGPlot *plot = 0;
    if (fHistogramDropDownBox->GetSelectedEntry()) {
        string name = fHistogramDropDownBox->GetSelectedEntry()->GetTitle();
        plot = QGPlot::GetPlotByName(name);
    }
    return plot;
}
 
void QGCalibrationWindow::HandleDrawButton()
{
    QGPlot *plot = GetCurrentPlot();
    if (plot) {
        plot->Plot();
    }
}
 
void QGCalibrationWindow::HandleHistogramDropDownBox(const char *text)
{
    SaveData();
    Clear();
    fCurrentHistogramName = text;
    LoadData(fCurrentHistogramName);
}
 
void QGCalibrationWindow::HandleSaveButton()
{
         // write data to file from maps
    SaveData();
         std::ofstream filestream;
         filestream.open(fOutputFilename.c_str(), std::ofstream::out);
 
         if(!filestream.good()) 
         {
                 cout << "Could not open file " << fOutputFilename << endl;
                 return;
         }
 
         std::vector<int> channels;
         std::vector<double> energies;
         std::vector<double> mins;
         std::vector<double> maxs;
         
         if(fMaxData.size() != fMinData.size())
         {
                 cout << "Number of max values set must equal number of min values!" << endl;
                 return;
         }
         
         // loop over channels
         map<string, map<QGCalibrationPeakFrame*, Double_t> >::iterator iter;
         for(iter=fMaxData.begin(); iter != fMaxData.end(); iter++)
         {
                string histname = iter->first;
                int channel;
                sscanf(histname.c_str(), "Channel_%d", &channel);
                
                if(fMaxData[histname].size() != fMinData[histname].size())
                {
                        cout << "Number of max values set must equal number of min values!" << endl;
                        return;
                }
                        
                // loop over peaks
                map<QGCalibrationPeakFrame*, Double_t>::iterator peakIter;
                for(peakIter=fMaxData[histname].begin(); peakIter != fMaxData[histname].end(); peakIter++)
                {
                        channels.push_back(channel);
                        energies.push_back((peakIter->first)->GetEnergy());
                        maxs.push_back(fMaxData[histname][peakIter->first]);
                        if(fMinData[histname].count(peakIter->first))
                        {
                                mins.push_back(fMinData[histname][peakIter->first]);    
                        }
                        else
                        {
                                cout << "Min value missing for channel " << channel;
                                cout << ", energy " << energies.back() << endl;
                                return;
                        }
                }
         }
 
         int nCols = 4;
         int nRows = channels.size();
         
     // MV FIXME: should use the QGlobalDataManager here...
         filestream << "# begin GUI@peaks" << endl;
         filestream << "# QMatrix" << endl;
         filestream << "# " << nRows << ' ' << nCols << endl;
         
         for(int i=0; i<nRows; i++)
         {
                 filestream << channels[i] << '\t';
                 filestream << energies[i] << '\t';
                 filestream << mins[i] << '\t';
                 filestream << maxs[i] << endl;
         }
         filestream << "# end peaks" << endl;
         filestream.close();
         return;
}
 
void QGCalibrationWindow::LoadData(const std::string& histogramName)
{
    if (fMinData.count(histogramName) != 0) {
        map<QGCalibrationPeakFrame*, Double_t>::const_iterator peakIter;
        for (peakIter = fMinData[histogramName].begin(); peakIter != fMinData[histogramName].end(); ++peakIter) {
            (peakIter->first)->SetMinAmplitude(peakIter->second);
        }
    }
    if (fMaxData.count(histogramName) != 0) {
        map<QGCalibrationPeakFrame*, Double_t>::const_iterator peakIter;
        for (peakIter = fMaxData[histogramName].begin(); peakIter != fMaxData[histogramName].end(); ++peakIter) {
            (peakIter->first)->SetMaxAmplitude(peakIter->second);
        }
    }
}
 
void QGCalibrationWindow::SaveData()
{
    if (fCurrentHistogramName != "") {
        vector<QGCalibrationPeakFrame*>::const_iterator peakIter;
        for (peakIter = fCalibrationPeakFrames.begin(); peakIter != fCalibrationPeakFrames.end(); ++peakIter) {
            if ((*peakIter)->IsMinAmplitudeSet()) {
                fMinData[fCurrentHistogramName][*peakIter] = (*peakIter)->GetMinAmplitude();
            } else {
                fMinData[fCurrentHistogramName].erase(*peakIter);
            }
            if ((*peakIter)->IsMaxAmplitudeSet()) {
                fMaxData[fCurrentHistogramName][*peakIter] = (*peakIter)->GetMaxAmplitude();
            } else {
                fMaxData[fCurrentHistogramName].erase(*peakIter);
            }
        }
    }
}
 
void QGCalibrationWindow::SetProperty(const string& key, const string& value)
{
    if (key == PEAK_KEY) {
        TString valueTString(value);
        if (valueTString.IsFloat()) {
            AddPeak(valueTString.Atof());
        }
    }
    if (key == CALIBRATION_OUTPUT_FILENAME_KEY) {
        fOutputFilename = value;
    }
}
 
void QGCalibrationWindow::SetUpHistograms()
{
    fHistogramDropDownBox->RemoveAll();
    
    Int_t id = 0;
    const list<QGHistogram*>& histograms = QGHistogram::GetHistograms();
    list<QGHistogram*>::const_iterator histogramIter;
    for (histogramIter = histograms.begin(); histogramIter != histograms.end(); ++histogramIter) {
        fHistogramDropDownBox->AddEntry((*histogramIter)->GetName(), id++);
    }
    fHistogramDropDownBox->Layout();
}