---

RawScanResult.cpp

Go to the documentation of this file.

#include "Sct/SctParameters.h"
#include "Sct/OutOfRangeError.h"

#include "ScanHeader.h"
#include "RawScanResult.h"
#include "ModuleConfiguration.h"
#include "ModuleDefectList.h"
#include "ModuleDefect.h"

#include <TH1.h>
#include <TH2.h>
#include <TROOT.h>

#include <sstream>

using namespace Sct;
using namespace std;


namespace SctData {

RawScanResult::RawScanResult(const ScanHeader& scan, const ModuleConfiguration& module, 
                 const ScanPoints& points, TH2D& scan_link0,  TH2D& scan_link1) throw() :
    ScanResult(scan, module, points), scanData_link0(&scan_link0),  scanData_link1(&scan_link1) {}
    
//Only for the builder:
RawScanResult::RawScanResult()  throw () {
}

RawScanResult::~RawScanResult() throw() {
}

string RawScanResult::getClassName() const throw() {
    return "SctData::RawScanResult";
}

string RawScanResult::getUniqueID() const throw() {
    return getHeader().getUniqueID();
}


string RawScanResult::getUniqueID(const ScanHeader& header) throw() {
    return header.getUniqueID();
}

TH2D& RawScanResult::getScanData(unsigned ilink) const throw(LogicError) {
    TH2D* data=0;
    if (ilink == 0) {
    data= scanData_link0.get();
    } else if ( ilink==1 )  {
    data= scanData_link1.get();
    } else {
    throw OutOfRangeError<unsigned>("RawScanResult::getScanData ilink ", __FILE__, __LINE__, ilink,0,1); 
    }
    if (!data) throw InvariantViolatedError("RawScanResult::getScanData no scan data", __FILE__, __LINE__) ;
    return *data;
}


/*
  TH1*  RawScanResult::getLinkOccupancy (const char* name, unsigned ilink, const ModuleDefectList* defects) const  throw (LogicError) {
  return getProjection(name, ilink, 0, nChannelLink-1, defects);
  }
  
  TH1*  RawScanResult::getChipOccupancy (const char* name, unsigned ichip, const ModuleDefectList* defects) const  throw (LogicError) {
  return getChipOccupancy(name, ichip/nChipLink, ichip%nChipLink, defects);
  }
  
  TH1*  RawScanResult::getChipOccupancy (const char* name, unsigned ilink, unsigned ichip, const ModuleDefectList* defects) const  throw (LogicError) {
  return getProjection(name, ilink, ichip*nChannelChip, (ichip+1)*nChannelChip-1, defects);
  }
  
  TH1*  RawScanResult::getChannelOccupancy (const char* name, unsigned istrip, const ModuleDefectList* defects) const  throw (LogicError) {
  return getChannelOccupancy(name, istrip/nChannelLink, istrip%nChannelLink, defects);
  }
  
  TH1*  RawScanResult::getChannelOccupancy (const char* name, unsigned ilink, unsigned istrip, const ModuleDefectList* defects) const  throw (LogicError) {
  return getProjection(name, ilink, istrip, istrip, defects);
  }
  
//Returns a projection from lowChan to highChan.
//Inclusive and channels start from 0.
TH1* RawScanResult::getProjection(const char* name, unsigned ilink, unsigned lowChan, unsigned highChan, const ModuleDefectList* defects) const throw (LogicError) {

if (lowChan>nChannelLink) throw OutOfRange<unsigned>("RawScanResult::getProjection lowChan ",lowChan,0,nChannelLink);
if (highChan>nChannelLink) throw OutOfRange<unsigned>("RawScanResult::getProjection highChan ",highChan,0,nChannelLink);

TH2& data = getScanData(ilink);
double* bins = points.getEdges();
TH1D* occ = new TH1D(name, "Raw data projection", points.getNPoints(), bins);
delete[] bins;    

//Explicit binomial errors.
for (unsigned int j=0; j<points.getNPoints(); ++j){
Stat_t n=points.getNEvents(j); 
double z=0;
unsigned int nChans = 0;

//Do projection
for (unsigned int i=lowChan; i<=highChan; ++i) {
if (defects) {
//Note that actual channel number is i + ilink*nChannelLink!
if (defects->hasSevereDefect(i+ilink*nChannelLink)) continue;
}
z += data.GetBinContent(i+1, j+1);
nChans++;
}

if (n==0 || nChans==0) {
ostringstream text;
text <<"RawScanResult::getProjection No triggers for point "<<j<<endl;
throw InvalidArgument(text.str(), MRS_DIAGNOSTIC);

occ->SetBinContent(j+1, z);
occ->SetBinError(j+1, 0);
continue;
}
n*=nChans;                              // number of triggers corrected for #channels

double err2=(z+1)*(n-z+1)/(n*n*n);
double occupancy=z/n;

occ->SetBinContent(j+1, occupancy);
occ->SetBinError(j+1,sqrt(err2));
}       
return occ;
}
*/

}

---