---

NPtGainAlgorithm.cpp

Go to the documentation of this file.

#include "NPtGainAlgorithm.h"
#include "AnalysisAlgorithmMap.h"
#include "AnalysisService.h"
#include "Sct/SctParameters.h"
#include "SctData/NPtGainTestResult.h"
#include "SctData/FitScanResult.h"
#include "SctData/FitObject.h"
#include "SctData/ResponseCurve.h"
#include "SctData/ModuleDefect.h"
#include "SctData/ModuleConfiguration.h"
#include "SctData/ChipConfiguration.h"
#include <boost/shared_ptr.hpp>

using namespace Sct;
using namespace SctData;
using namespace boost;

using std::auto_ptr;

namespace SctAnalysis {
    

    shared_ptr<AnalysisAlgorithm> NPtGainAlgorithm::clone(const TestData& testData, const string& moduleName) const throw() {
    return shared_ptr<AnalysisAlgorithm>(new NPtGainAlgorithm(testData, moduleName));
    }

    shared_ptr<ResponseCurve> NPtGainAlgorithm::getResponseCurve(unsigned int nPts) throw(LogicError){
    if (nPts <= 3) {
        return shared_ptr<ResponseCurve> (new LinearResponseCurve());
    } else {
        return shared_ptr<ResponseCurve> (new ExponentialResponseCurve());
    }
    }

    void NPtGainAlgorithm::setResponseCurve(auto_ptr<ResponseCurve> rc) throw() {
    static shared_ptr<ResponseCurve> s_responseCurve=shared_ptr<ResponseCurve>(rc.release());
    }

bool NPtGainAlgorithm::inMap = AnalysisAlgorithmMap::instance().setAlgorithm("NPtGainTest", auto_ptr<AnalysisAlgorithm>(new NPtGainAlgorithm()));

void NPtGainAlgorithm::canAddFitScanResult(const string& name) throw(LogicError, IoError) {
    shared_ptr<NPtGainTestResult> result = dynamic_pointer_cast<NPtGainTestResult> ( getTestResult() );
    
    //cout << "NPtGainAlgorithm: adding fit: " << name <<endl;

    if (result.get()==0){
    //cout << "NPtGainAlgorithm: initialising fit" << endl;
    //Create and initialize an NPtGainTestResult
    result = shared_ptr<NPtGainTestResult> (new NPtGainTestResult());
    setTestResult(result);
    
    initializeTestResult();
    
    result->setChipDataSize(nChipModule);
    result->setChannelDataSize(nChannelModule);

    try{
        result->setSpecialScanPointValue(2.0);
    } catch (Sct::Throwable& e){
        e.sendToMrs(MRS_ERROR);
    }
    
    }

    addFit(name);

    //cout << result->hasAllFits() << endl;

    // we need all of the fits
    if ( !result->hasAllFits() ) return;

    //Do chips
    for (unsigned int i=0; i<nChipModule; ++i) {
        setupGraph(i, &FitScanResult::getChipFit, *result, result->getChipData(i), true);
        doFit(i, &FitScanResult::getChipFit, *result, result->getChipData(i));
    }

    //Do channels
    for (unsigned int i=0; i<nChannelModule; ++i) {
        setupGraph(i, &FitScanResult::getChannelFit, *result, result->getChannelData(i), false);
        doFit(i, &FitScanResult::getChannelFit, *result, result->getChannelData(i));
        doDefect(Channel(i), result->getDefects(), 
         result->getChannelData(i), result->getChipData(i/nChannelChip));
    }
    
    result->setPassed(true);
    
    finish();
}
 
//Setup the graphs - also prune points
void NPtGainAlgorithm::setupGraph(unsigned int id, getFitFunction fitFunc, NPtGainTestResult& test, NPtGainTestResultData& testData, bool trimPoints) throw(LogicError) {
    shared_ptr<TGraph> g (new TGraph(test.getNScans()));
    if (!g)
        throw InvariantViolatedError("NPtGainTestResult::setupGraph couldn't make TGraph", __FILE__, __LINE__);
    
    unsigned int lastPoint = test.getNScans()-1;
    //Filter out points above 5fC if they are broad and we have more than 5 points
    if (trimPoints && test.getNScans() > 5) {
    double sigmaCut = 0;
    for (unsigned int i=0; i<test.getNScans(); ++i) {
        sigmaCut+= (test.getFit(i).get()->*fitFunc)(id).getParameter("Sigma");
    }
    sigmaCut *= 1.5/test.getNScans();   //We want 1.5*mean sigma
    for (unsigned int i=test.getNScans() - 1; i>4; --i) {
        if (test.getTestPointAt(i) > 5 && (test.getFit(i).get()->*fitFunc)(id).getParameter("Sigma") > sigmaCut) {
        lastPoint = i;
        }
    }
    //Note we should only trim points for chips...
    if (lastPoint != test.getNScans() - 1) {
        ostringstream oss;
        oss << "Points trimed from response curve for chip: " << id << ". Last point " << lastPoint << " with charge " << test.getTestPointAt(lastPoint);
        test.addComment(oss.str());
    }
    }
    
    for (unsigned int j = 0; j <= lastPoint; ++j) {
        g->SetPoint(j, test.getTestPointAt(j), (test.getFit(j).get()->*fitFunc)(id).getParameter("Mean"));
    }
    testData.graph = g;
}

void NPtGainAlgorithm::doFit(unsigned int id, getFitFunction fitFunc, NPtGainTestResult& test,
                              NPtGainTestResultData& testData) throw(LogicError) {
    shared_ptr<ResponseCurve> r=getResponseCurve(test.getNScans());
    testData.rc = r;
    
    //testData.graph->Fit(&testData.rc->getFunction(), "NQ", "", 0, 10);
    // replaced below with generalised fitting, 17/7/03 Alan Barr

    testData.rc->getFunction()->SetRange(0,10);
    AnalysisService::instance().getFitStrategy().fitTGraph(*testData.graph, *testData.rc->getFunction() );
    
    testData.gain = testData.rc->getGain(test.getSpecialScanPointValue());

    shared_ptr<const FitScanResult> specialFit = test.getFit(test.getSpecialScanIndex());
    //6250 is a magic number that converts noise to ENC
    if (testData.gain != 0) testData.noise = 6250 * (specialFit.get()->*fitFunc)(id).getParameter("Sigma") / testData.gain;
    else  testData.noise = 0;
    testData.offset= testData.rc->getFunction()->Eval(0.);
}

void NPtGainAlgorithm::doDefect(const ModuleElement& element, ModuleDefectList& defects, 
                const NPtGainTestResultData& data,
                const NPtGainTestResultData& comparisonData) throw(LogicError) {
    if (data.gain < ModuleDefect::LO_GAIN.getParameter() * comparisonData.gain)
        defects.addDefect(ModuleDefect::LO_GAIN, element);
    else if (data.gain > ModuleDefect::HI_GAIN.getParameter() * comparisonData.gain)
        defects.addDefect(ModuleDefect::HI_GAIN, element);

    if (data.offset < ModuleDefect::LO_OFFSET.getParameter())
        defects.addDefect(ModuleDefect::LO_OFFSET, element);
    else if (data.offset > ModuleDefect::HI_OFFSET.getParameter())
        defects.addDefect(ModuleDefect::HI_OFFSET, element);

    if (data.noise < ModuleDefect::UNBONDED.getParameter())
        defects.addDefect(ModuleDefect::UNBONDED, element);
    else if (data.noise < ModuleDefect::PARTBONDED.getParameter())
        defects.addDefect(ModuleDefect::PARTBONDED, element);
    else if (data.noise > ModuleDefect::NOISY.getParameter() * comparisonData.noise)
        defects.addDefect(ModuleDefect::NOISY, element);
}
}

---