Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Related Pages

RawDisplayer.cpp

00001 #include "RawDisplayer.h"
00002 #include "DisplayManager.h"
00003 #include "DisplayInfo.h"
00004 
00005 #include "SctData/ModuleConfiguration.h"
00006 #include "SctData/ResultHeader.h"
00007 #include "SctData/ConfigurationVariable.h"
00008 #include "SctData/RawScanResult.h"
00009 #include "SctData/OccupancyProjector.h"
00010 #include "SctData/ModuleElement.h"
00011 #include "SctData/DefaultVariable.h"
00012 #include "ScanResultWriter/dataTypes.h"
00013 #include "CommonWithDsp/ABCD/ABCDscans.h"
00014 #include <TH1.h>
00015 #include <TH2.h>
00016 #include <TCanvas.h>
00017 #include <TApplication.h>
00018 #include <TStyle.h>
00019 #include <TPaletteAxis.h>
00020 
00021 #include <iostream>
00022 #include <vector>
00023 #include <boost/lexical_cast.hpp>
00024 
00025 using namespace Sct;
00026 using namespace SctData;
00027 using namespace boost;
00028 
00029 namespace SctDataDisplay {
00030     
00031 
00032 class RawDisplayData : public DisplayData {
00033 public:
00034     vector<shared_ptr<TCanvas> > canvas;
00035     shared_ptr<const RawScanResult> scan;
00036     vector<shared_ptr<TH1> > histos;
00037     vector<shared_ptr<TH2> > event_occ;
00038 };
00039 
00040 bool RawDisplayer::inMap = DisplayManager::addToMap("SctData::RawScanResult", shared_ptr<Displayer>(new RawDisplayer()));
00041     
00042 shared_ptr<DisplayData> RawDisplayer::display(shared_ptr<const Sct::Serializable> serial, const DisplayInfo& info, std::ostream& os) {
00043     
00044     shared_ptr<RawDisplayData> data (new RawDisplayData());
00045     data->scan = dynamic_pointer_cast<const RawScanResult>(serial);
00046 
00047     const ConfigurationVariable& var = data->scan->getHeader().getVariable();
00048     
00049     if (data->scan->getDataType() != SR_DT_RAWHIST  && 
00050     var != *DefaultVariable::instance(ST_NMASK) &&
00051     var != *DefaultVariable::instance(ST_TOKEN) &&
00052     info.displayChannels.size() + info.displayChips.size() != 0) {
00053       displayProjs(info, *data);
00054     }
00055     
00056     string name = "Raw." + (string)data->scan->getUniqueID();
00057     shared_ptr<TCanvas> c = createCanvas(name, name);
00058     data->canvas.push_back(c);
00059     TPad* p1=new TPad("Data","Data",0.,0.,0.75,1.0);
00060     TPad* p2=new TPad("Data","Data",0.75,0.4,1.0,0.95);
00061     p1->Draw();
00062     p2->Draw();
00063 
00064     p2->cd();
00065     p2->SetLeftMargin(0.2);
00066     p2->SetRightMargin(0.3);
00067     //p2->SetLogz();
00068     const SctData::ScanPoints& pts = data->scan->getPoints();
00069     double* bins = pts.getEdgesAscending();
00070     int npoints= pts.getNPoints();
00071     shared_ptr<TH2> trigs (new TH2F("Triggers","Triggers",2,0,2,npoints,bins));
00072     for (int i=0; i<npoints; ++i){
00073       int ipt=pts.ascending() ? i : npoints-i-1;
00074       trigs->Fill(1.5, pts[ipt],data->scan->getPoints().getNEvents(ipt));
00075       trigs->Fill(0.5, pts[ipt],data->scan->getPoints().getNErrorEvents(ipt));
00076     }
00077     delete[] bins;
00078     trigs->GetYaxis()->SetTitleOffset(1.8);
00079     trigs->GetXaxis()->SetLabelSize(0.08);
00080     trigs->GetYaxis()->SetLabelSize(0.08);
00081     trigs->GetZaxis()->SetLabelSize(0.08);
00082     trigs->GetXaxis()->SetBinLabel(1,"Errors");
00083     trigs->GetXaxis()->SetBinLabel(2,"Events");
00084     
00085     gPad->SetLogz();
00086     gPad->SetTheta(10);
00087     data->histos.push_back(trigs);
00088     displayHistogram(trigs,"lego");
00089     
00090     p1->cd();
00091     //gStyle->SetPalette(30);
00092     gPad->Divide(1,2,0.01,0.01);
00093     for (int ilink=0; ilink<2; ++ilink){
00094       p1->cd(ilink+1);
00095       data->scan->getScanData(ilink).SetMinimum(0.);
00096       string x_title;
00097       switch(data->scan->getDataType()) {
00098       case SR_DT_RAWHIST: { x_title="Time Bin"; break;}
00099       case SR_DT_SLICE: case SR_DT_SLICE_COMPRESSED: { x_title="Channel"; break;}
00100       }
00101       shared_ptr<TH2> datah(dynamic_cast<TH2*>(data->scan->getScanData(ilink).Clone()));
00102       
00103       for (unsigned iy=1; iy<=datah->GetNbinsY(); ++iy){
00104     int ipt=pts.ascending() ? iy-1 : npoints-iy;
00105     for (unsigned ix=1; ix<=datah->GetNbinsX(); ++ix){
00106       double val=datah->GetBinContent(ix,iy);
00107       double triggers = data->scan->getPoints().getNEvents(ipt);
00108       if (triggers!=0.) val/=triggers;
00109       datah->SetBinContent(ix,iy,val);
00110     }
00111       }
00112       datah->SetXTitle(x_title.c_str());
00113       datah->SetYTitle(var.getVariableName().c_str());
00114       datah->SetStats(false);
00115       datah->GetXaxis()->CenterTitle();
00116       datah->GetYaxis()->CenterTitle();
00117       data->histos.push_back(datah);
00118       displayHistogram(datah,"colz");
00119     }
00120 
00121     if (info.occupancyHistograms && data->scan->nOccupancyPerEvent()!=0){
00122       displayOccupancyPerEvent(info, *data);
00123     }else if(info.occupancyHistograms){
00124       std::cerr << "No OPE data available" << std::endl;
00125     }
00126 
00127     return data;
00128 }
00129 
00130 void RawDisplayer::displayOccupancyPerEvent(const DisplayInfo& info, RawDisplayData& data){
00131   ostringstream oss;
00132   oss << "Raw." << data.scan->getHeader().getUniqueID() << "_OPE";
00133   const char*const name = oss.str().c_str();
00134   shared_ptr<TCanvas> canvas_occ = createCanvas(name, name);
00135   data.canvas.push_back(canvas_occ);
00136   const unsigned n=data.scan->nOccupancyPerEvent();
00137   divideCanvas(n, *canvas_occ);
00138   for (unsigned i=0; i<n; ++i){
00139     canvas_occ->cd(i+1);
00140     gPad->SetLogz();
00141     gPad->SetLeftMargin(0.17);
00142     gPad->SetBottomMargin(0.15);
00143     gPad->SetTopMargin(0.03);
00144     gPad->SetRightMargin(0.03);
00145     TH2D& hist = const_cast<TH2D&> ( data.scan->getOccupancyPerEvent(i) );
00146     ostringstream title;
00147     title << "Chip " << i;
00148     hist.GetYaxis()->SetTitleOffset(1.2);
00149     hist.GetXaxis()->SetLabelSize(0.05);
00150     hist.GetYaxis()->SetLabelSize(0.05);
00151     hist.GetXaxis()->SetTitleSize(0.05);
00152     hist.GetYaxis()->SetTitleSize(0.05);
00153     hist.GetXaxis()->CenterTitle();
00154     hist.GetYaxis()->CenterTitle();
00155     hist.SetTitle(title.str().c_str());
00156     displayHistogram(hist,"colz");
00157   }
00158 }
00159     
00160 void RawDisplayer::displayProjs(const DisplayInfo& info, RawDisplayData& data) {
00161   if (!info.projections) return;
00162     unsigned int nMax = min((unsigned int)25, info.displayChannels.size() + info.displayChips.size());
00163     unsigned int j=0;
00164     shared_ptr<TCanvas> c;
00165     
00166     //Now show some projections for channels and chips
00167     OccupancyProjector occ(*data.scan);
00168 
00169     for (unsigned int i=0; i<info.displayChips.size(); ++i, ++j) {
00170     if (j%nMax == 0) {
00171       std::string canvasname = "Raw." + (string)data.scan->getHeader().getUniqueID() + "_chipProj";
00172             c = createCanvas(canvasname, canvasname);
00173         data.canvas.push_back(c);
00174         divideCanvas(nMax, *c);
00175             j=0;
00176         }
00177     c->cd(j+1);
00178     string name = "chip" + lexical_cast<string>(info.displayChips[i]) + (string)data.scan->getUniqueID();
00179     shared_ptr<TH1> chip(occ.getOccupancy(name.c_str(), ModuleElement::Chip(info.displayChips[i])).release());
00180     gPad->SetLeftMargin(0.2);
00181     gPad->SetBottomMargin(0.15);
00182     gPad->SetTopMargin(0.07);
00183     gPad->SetRightMargin(0.03);
00184     chip->GetYaxis()->SetTitleOffset(1.35);
00185     chip->GetXaxis()->SetLabelSize(0.05);
00186     chip->GetYaxis()->SetLabelSize(0.05);
00187     chip->GetXaxis()->SetTitleSize(0.05);
00188     chip->GetYaxis()->SetTitleSize(0.05);
00189     chip->GetXaxis()->CenterTitle();
00190     chip->GetYaxis()->CenterTitle();
00191     chip->GetXaxis()->SetNdivisions(506);
00192     data.histos.push_back(chip);
00193     displayHistogram(chip);
00194     }
00195     
00196     
00197     for (unsigned int i=0; i<info.displayChannels.size(); ++i, ++j) {
00198     if (j%nMax == 0) {
00199       std::string canvasname = "Raw." + (string)data.scan->getHeader().getUniqueID() + "_chanProj";
00200             c = createCanvas(canvasname, canvasname);
00201         data.canvas.push_back(c);
00202         divideCanvas(nMax, *c);
00203             j=0;
00204         }
00205     c->cd(j+1);
00206     
00207     string name = "channel" + lexical_cast<string>(info.displayChannels[i]) + (string)data.scan->getUniqueID();
00208     shared_ptr<TH1> channel(occ.getOccupancy(name.c_str(), ModuleElement::Channel(info.displayChannels[i])).release());
00209     data.histos.push_back(channel);
00210     displayHistogram(channel);
00211     }
00212 }   
00213 }

Generated on Thu Feb 10 02:40:12 2005 for SCT DAQ/DCS Software - C++ by doxygen 1.3.5