---

TrimRangeAlgorithm.cpp

Go to the documentation of this file.

#include "TrimRangeAlgorithm.h"
#include "AnalysisAlgorithmMap.h"
#include "AnalysisService.h"
#include "Sct/SctParameters.h"
#include "Sct/UnsupportedOperationError.h"
#include "SctData/TrimRangeTestResult.h"
#include "SctData/FitScanResult.h"
#include "SctData/FitObject.h"
#include "SctData/ModuleDefect.h"
#include "SctData/ModuleConfiguration.h"
#include "SctData/ChipConfiguration.h"
#include "SctData/ResponseCurve.h"
#include <boost/shared_ptr.hpp>
#include <algorithm>
#include <memory>

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

namespace SctAnalysis {
    
    bool TrimRangeAlgorithm::inMap = AnalysisAlgorithmMap::instance().setAlgorithm("TrimRangeTest", auto_ptr<AnalysisAlgorithm>(new TrimRangeAlgorithm()));

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

    bool TrimRangeAlgorithm::s_targetVariation = false;
    bool TrimRangeAlgorithm::s_rangeVariation = true;

void TrimRangeAlgorithm::canAddFitScanResult(const string& name) throw(LogicError, IoError) {

    bool debug=false;
    
    shared_ptr<TrimRangeTestResult> result = dynamic_pointer_cast<TrimRangeTestResult> ( getTestResult() );
    
    if (result.get()==0){
    //Create and initialize an TrimRangeTestResult
    result = shared_ptr<TrimRangeTestResult> (new TrimRangeTestResult());
    setTestResult(result);
    initializeTestResult();
    }
    
    addFit(name);

    // we need all of the fits
    if ( !result->hasAllFits() ) return;
    
    /* 
       STAGE 1 : make sense of the incoming data.
       make a vector of all ranges, all points in those ranges and the 
       appropriate scan number.
    */
    std::vector<TrimRange> all_ranges = createRanges(*result);
    
    /* 
       STAGE 2 : make graphs of trim against vt50 for each chip
       and each channel and each range
    */
    
    shared_ptr<SctData::TrimRangeTestResult::ChipTrimData> dataArray[all_ranges.size()][nChipModule];
    
    // loop over trim ranges
    for (unsigned irange=0; irange<all_ranges.size(); ++irange){
    
    TrimRange& range = all_ranges[irange];
    
    // loop over chips
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        dataArray[irange][ichip] =
        shared_ptr<TrimRangeTestResult::ChipTrimData>(new TrimRangeTestResult::ChipTrimData());
        
        // loop over trim-scan points
        for (unsigned ipoint=0; ipoint<range.points.size(); ++ipoint){
        
        TrimPoint& this_point = range.points[ipoint];    
        shared_ptr<const FitScanResult> fitted=result->getFit(this_point.scan);
        const ModuleDefectList& fitDefects=fitted->getDefects();
        
        // loop over channels in that chip.
        for (unsigned iChanInChip=0; iChanInChip<nChannelChip; ++iChanInChip){
            unsigned ichannel=iChanInChip + ichip*nChannelChip;
            
            // get the relevant TrimData object
            Stat<TrimRangeTestResult::TrimData>& trdt = dataArray[irange][ichip]
            ->channelData.modifyAt(iChanInChip);
            
            // channel is valid if there are no defects on it.
            if(fitDefects.severeDefectEncompassingElement( Channel(ichannel) )) {
            trdt.valid=false;
            if (debug) {
                cout << "Severe defect on Channel " << ichannel << endl;
                fitDefects.getDefectsEncompassingElement( Channel(ichannel))->print(cout);
            }
            }
            if (trdt.valid){
            float gr_mean = fitted->getChannelFit(ichannel).getParameter(1);
            float gr_value = this_point.value;
            trdt.value.graph.push_back(std::make_pair(gr_mean, gr_value));
            } // if channel is valid
        } // loop over channels 
        } // loop over scan-points
    } // loop over chips
    } // loop over ranges
    
    
    /*
      STAGE 3:
      create a vector of target s starting from firstTarget in uniform steps
      to a total of ntargets
    */
    std::vector<float> target;
    for (unsigned itarg=0; itarg<nTargets(); ++itarg){
    target.push_back (firstTarget() + itarg * targetStep());
    }
    
    shared_ptr<const TrimRangeTestResult::ChipTrim> trimArray[all_ranges.size()][nChipModule][nTargets()];   
    
    /*
      STAGE 4a: fit the graphs 
      STAGE 4b: find the number of trimmable channels for each in a series of targets
    */
    for (unsigned irange=0; irange<all_ranges.size(); ++irange){
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        // 4a:
        if (dataArray[irange][ichip].get()==0){
        throw InvariantViolatedError("TrimRangeAlgorithm: dataArray pointer should not be zero!", __FILE__, __LINE__);
        }
        doTrimDataFit( *dataArray[irange][ichip] );
        for (unsigned itarget=0; itarget<nTargets(); ++itarget){
        //4b:
        trimArray[irange][ichip][itarget] = getChipTrim(*dataArray[irange][ichip], 
                                target[itarget],
                                all_ranges[irange].range);
        }       
    }
    }
    
    /*
      STAGE 5 select the best trim target which trims the maximum number of channels
    */
    
    unsigned best_target_for_chip[nChipModule];       // index of vector targets
    unsigned best_range_for_chip[nChipModule];        // index of vector all_ranges
    
    // 5a no chip-to-chip variation:
    if ( !allowTrimTargetVariation() && !allowTrimRangeVariation() ){
    unsigned max_trimmed=0;
    unsigned target_lo=0, target_hi=0;
    
    for (unsigned irange=0; irange<all_ranges.size(); ++irange){
        for( unsigned itarget=0; itarget<nTargets(); ++itarget){
        unsigned n_trimmed=0;
        /* find number of channels which are trimmable in the module */
        for (unsigned ichip=0; ichip<nChipModule; ++ichip){
            n_trimmed+=trimArray[irange][ichip][itarget]->channelTrim.n();
            
        }
        if (n_trimmed>max_trimmed) {
            target_lo=itarget;
            best_range_for_chip[0] = irange;
            max_trimmed=n_trimmed;
        }
        if (n_trimmed==max_trimmed && irange==best_range_for_chip[0]) {
            target_hi=itarget;
        }
        }
    }
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        best_range_for_chip[ichip]=best_range_for_chip[0];
        best_target_for_chip[ichip]=(target_hi+target_lo)/2;
    }
    } else
    
    // 5b chip-to-chip target variation:
    if ( allowTrimTargetVariation() && !allowTrimRangeVariation() ){
    unsigned target_lo[nChipModule];
    unsigned target_hi[nChipModule];
    unsigned max_trimmed[nChipModule];
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        target_lo[ichip]=target_hi[ichip]=max_trimmed[ichip]=0;
    }
    
    for (unsigned irange=0; irange<all_ranges.size(); ++irange){
        for( unsigned itarget=0; itarget<nTargets(); ++itarget){
        unsigned n_trimmed=0;
        /* find number of channels which are trimmable in the module */
        for (unsigned ichip=0; ichip<nChipModule; ++ichip){
            n_trimmed = trimArray[irange][ichip][itarget]->channelTrim.n();
            
            if (n_trimmed>max_trimmed[ichip] ) {
            target_lo[ichip]=itarget;
            best_range_for_chip[ichip] = irange;
            }
            if (n_trimmed==max_trimmed[ichip] && irange==best_range_for_chip[ichip]) {
            target_hi[ichip]=itarget;
            }
        }
        }
    }
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        best_target_for_chip[ichip]=(target_hi[ichip]+target_lo[ichip])/2;
    }
    } else
    
    // 5c chip-to-chip range variation:
    if ( !allowTrimTargetVariation() && allowTrimRangeVariation() ){
//  cout << "stage 5c"<<endl;
    unsigned target_lo=0;
    unsigned target_hi=0;
    unsigned total_channels_trimmed_max=0;
    unsigned total_range_lo=0;

    for( unsigned itarget=0; itarget<nTargets(); ++itarget){
        if (debug) cout << "TARGET " << itarget << endl;
        unsigned total_channels_trimmed=0;
        unsigned range_total=0;
        
        for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        unsigned best_range=0;
        unsigned max = 0;

        for (unsigned irange=0; irange<all_ranges.size(); ++irange){
            unsigned n_trimmed = trimArray[irange][ichip][itarget]->channelTrim.n();

            // if this is the lowest range with the maximum number of channels:
            if (n_trimmed > max || 
            ( all_ranges[irange].range < all_ranges[best_range].range 
              && n_trimmed==max)) {
            best_range = irange;
            max = n_trimmed;
            }
        }
        // find the total number of channels trimmed
        total_channels_trimmed+=max;
        range_total+=all_ranges[best_range].range ;
        }
        if (debug) cout << "  TOTAL = " <<  total_channels_trimmed << " for " << range_total << endl;
        
        if (total_channels_trimmed > total_channels_trimmed_max || 
        ( total_channels_trimmed == total_channels_trimmed_max && 
          range_total < total_range_lo ) ) {
        target_lo=itarget;
        total_range_lo=range_total;
        total_channels_trimmed_max=total_channels_trimmed;
        if (debug) cout << " ...... modified lower target" << endl;
        }
        
        if (total_channels_trimmed == total_channels_trimmed_max && 
        total_range_lo==range_total ){
        target_hi=itarget;
        if (debug) cout << " ...... modified upper target" << endl;
        }
        
    }
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        best_target_for_chip[ichip]=(target_hi+target_lo)/2;
        // know the target, get the ranges again:
        if (debug) cout << endl << " --> CHIP " << ichip << endl;
        unsigned max=0;
        best_range_for_chip[ichip]=0;
        
        for (unsigned irange=0; irange<all_ranges.size(); ++irange){
        unsigned n_trimmed = trimArray[irange][ichip][best_target_for_chip[ichip]]->channelTrim.n();
        if (debug) cout << "R" << irange << " -> " << n_trimmed << endl;
        if (n_trimmed> max || 
            ( all_ranges[irange].range < all_ranges[best_range_for_chip[ichip]].range 
              && n_trimmed==max)) {
            best_range_for_chip[ichip] = irange;
            max=n_trimmed;
            if (debug) cout << "best range changed to #" << irange << " = " << all_ranges[irange].range << endl;
        }
        }
    }
    } else {
    throw UnsupportedOperationError("Trim Range Algorithm not implimented for desired options!", __FILE__, __LINE__);
    }    

    /* STAGE 6 fill output TestResult data */
    if (debug) cout << "stage 6"<<endl;

    {
    // get a chip configuration for an example chip:
    const ChipConfiguration& config=result->getFit(0)->getConfiguration().getChipConfiguration(0);
    auto_ptr<ResponseCurve> rc = ResponseCurveMap::getMap().get(config);
    float cal_charge_mV = result->getFit(0)->getConfiguration().getChipConfiguration(0).getCalCharge()*2.5 ;
    float cal_charge_fC = rc->getFunction()->Eval(cal_charge_mV);

    result->charge = cal_charge_fC;
    result->type = allowTrimRangeVariation() ? (unsigned)-1 : best_range_for_chip[0] ;
    result->algorithm = allowTrimTargetVariation() ? 1 : 0 ;
    }
    
    bool pass = true;

    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
    if (debug) cout << "  CHIP " << ichip << endl;
    unsigned best_range  = best_range_for_chip[ichip];
    unsigned best_target = best_target_for_chip[ichip];
    
    if (debug) cout << "    optimum range = " <<  best_range 
            << ", target #" << best_target 
            << " = " << target[best_target] 
            << ", ntrim=" << trimArray[best_range][ichip][best_target_for_chip[ichip]]->channelTrim.n() << endl;
    
    result->chipTrim[ichip] = 
        trimArray [best_range] [ichip] [best_target];
    result->chipTrimData[ichip]=
        dataArray[best_range] [ichip];

    const Stats<double> offsets = dataArray[best_range][ichip]->getOffsets();
    const Stats<double> steps   = dataArray[best_range][ichip]->getSteps();
    
    double stepmin=0, stepmax=16;
    switch (all_ranges[best_range].range){
    case 0 : stepmin = 1.5 ; stepmax = 5.0 ; break; 
    case 1 : stepmin = 5.0 ; stepmax = 8.5 ; break;
    case 2 : stepmin = 8.5 ; stepmax = 12.0; break;
    case 3 : stepmin = 12.0; stepmax = 15.5; break;
    }
// Chip Defects:
    if (steps.mean() < stepmin || steps.mean() > stepmax ){
        result->getDefects().addDefect(ModuleDefect::TR_RANGE, Chip(ichip));
    }
// Channel Defects:
    for (unsigned iChanInChip=0; iChanInChip<nChannelChip ; ++iChanInChip){
// Step Defects:
        if (steps.getAt(iChanInChip).valid &&
        ( fabs( steps.getAt(iChanInChip).value - steps.mean() ) 
          > ModuleDefect::TR_STEP.getParameter() * sqrt(steps.var() ) ) ) { 
        result->getDefects().addDefect(ModuleDefect::TR_STEP, 
                           Channel(ichip*nChannelChip+iChanInChip));
        pass = false;
        }
// Offset Defects:
        if (offsets.getAt(iChanInChip).valid &&
        ( fabs( offsets.getAt(iChanInChip).value - offsets.mean() ) 
          > ModuleDefect::TR_OFFSET.getParameter() * sqrt(offsets.var() ) ) ) { 
        result->getDefects().addDefect(ModuleDefect::TR_OFFSET, 
                           Channel(ichip*nChannelChip+iChanInChip));
        pass = false;
        }
// Untrimmable Defects:
        if (result->chipTrim[ichip]->channelTrim.getAt(iChanInChip).valid==false){
        result->getDefects().addDefect(ModuleDefect::TR_NOTRIM, Channel(ichip*nChannelChip + iChanInChip));
        pass = false;
        } // if valid
    }// Channel loop
    }// chip loop
    
    result->setPassed(pass);
    
    finish();
}

    
    /* fit the trim data with a line */
    void TrimRangeAlgorithm::doTrimDataFit(TrimRangeTestResult::ChipTrimData& chipData) throw() {
    for (unsigned iChanInChip=0; iChanInChip<nChannelChip; ++iChanInChip){
        Stat<TrimRangeTestResult::TrimData>& trimdata = chipData.channelData.modifyAt(iChanInChip);

        trimdata.valid=false;
        trimdata.value.p0 = 0;
        trimdata.value.p1 = 0;
        
        if (trimdata.value.graph.empty())  continue;
        
        float xbar=0, ybar=0, x2bar=0, xybar=0;
        const unsigned n=trimdata.value.graph.size();

        for (unsigned ipoint = 0; ipoint<n; ++ipoint){
        const float& x=trimdata.value.graph[ipoint].first;
        const float& y=trimdata.value.graph[ipoint].second;
        xbar  += x;
        ybar  += y;
        x2bar += x*x;
        xybar += x*y;
        }

        const float det = n*x2bar - xbar*xbar;
        if (det>0){
        trimdata.value.p0 = (x2bar*ybar - xbar*xybar) / det;
        trimdata.value.p1 = (n*xybar - xbar*ybar) / det;
        trimdata.valid=trimdata.value.p1>0;
        }
    }   
    }
    
    /* interpreet the incoming data as a series of scans over different ranges */
    std::vector<TrimRangeAlgorithm::TrimRange> TrimRangeAlgorithm::createRanges(const TestResult& result) throw() {
    // Check all chips in each scan have the same range.
    // if they don't, then analyse all ranges together.
    std::vector<TrimRangeAlgorithm::TrimRange> all_ranges;
    
    bool inputRangeVariesChipToChip=false;
    
    for (unsigned iscan=0; iscan<result.getNScans(); ++iscan){
        shared_ptr<const FitScanResult> fitted = result.getFit(iscan);
        for (unsigned ichip=1; ichip<nChipModule; ichip++){
        if (fitted->getConfiguration().getChipConfiguration(ichip).getTrimRange()
            != fitted->getConfiguration().getChipConfiguration(0).getTrimRange()){
            inputRangeVariesChipToChip=true;
        }
        }
    }
    
    for (unsigned iscan=0; iscan<result.getNScans(); ++iscan){
        shared_ptr<const FitScanResult> fitted = result.getFit(iscan);

        // find the trim range for module 0 
        int range_value=fitted->getConfiguration().getChipConfiguration(0).getTrimRange();
        // find the trim for channel 0
        int trim_value=fitted->getConfiguration().getChipConfiguration(0).getTrim(0);

        std::vector<TrimRange>::iterator it = all_ranges.begin();
        while (it!=all_ranges.end()){
        if ( (*it).range == range_value ) {break;}
        ++it;
        }
        if (it==all_ranges.end() ){ // new trim range?
        // if there is chip to chip range variation, treat it all as one range
        if ( !inputRangeVariesChipToChip || all_ranges.empty() ){
            all_ranges.push_back(TrimRange(range_value));
        }
        it=all_ranges.end()-1;
        }
        
        // store in that range the trim value and the scan identifier.  
        (*it).points.push_back(TrimPoint(trim_value, iscan) );
    }
    // sort by range value.
    sort(all_ranges.begin(), all_ranges.end());
    return all_ranges;
    }

    
    shared_ptr<const TrimRangeTestResult::ChipTrim> TrimRangeAlgorithm::getChipTrim(const TrimRangeTestResult::ChipTrimData& data, const float target, const short unsigned range) throw(){
    
    shared_ptr<SctData::TrimRangeTestResult::ChipTrim> chipTrim (new SctData::TrimRangeTestResult::ChipTrim() );
    chipTrim->target=target;
    chipTrim->range =range;

    for (unsigned iChanInChip=0; iChanInChip<nChannelChip; ++iChanInChip){ 
        Stat<TrimRangeTestResult::TrimData> d= data.channelData.getAt(iChanInChip);
        Stat<TrimRangeTestResult::Trim>& t= chipTrim->channelTrim.modifyAt(iChanInChip);
        
        if (!d.valid){t.valid=false; continue; }
        
        // record the trim value.
        int i_trim=d.value.getTrim(target);
        
        // check if trimmable - if not, then do your best
        if ( i_trim>=0 && i_trim<=15) {
        t.valid=true;
        t.value.trim = i_trim;
        } else {
        t.valid=false;
        if (i_trim<0) t.value.trim = 0;
        if (i_trim>15) t.value.trim = 15;
        }
        
        t.value.vthr = d.value.getVthr(i_trim);
    }
    return chipTrim;
    }


} // end of namespace SctAnalysis

---