C++ Trace::HasValue方法代码示例

//********** Analyze **********
void WaveformAnalyzer::Analyze(Trace &trace,
			       const string &detType, 
			       const string &detSubtype)
{
    TraceAnalyzer::Analyze(trace, detType, detSubtype);
    
    if(detType == "vandleSmall" || detType == "vandleBig" 
       || detType == "scint" || detType == "pulser" 
       || detType == "tvandle") {

	unsigned int maxPos = trace.FindMaxInfo();

	if(trace.HasValue("saturation")) {
	    EndAnalyze();
	    return;
	}

	unsigned int waveformLow = GetConstant("waveformLow");
	unsigned int waveformHigh = GetConstant("waveformHigh");
	unsigned int startDiscrimination = 
	    GetConstant("startDiscrimination");

	double qdc = trace.DoQDC(maxPos-waveformLow, 
				 waveformHigh+waveformLow);

	trace.InsertValue("qdcToMax", qdc/trace.GetValue("maxval"));

	if(detSubtype == "liquid")
	    trace.DoDiscrimination(startDiscrimination, 
	 			   waveformHigh - startDiscrimination);
    } //if(detType
    EndAnalyze();
}

void FittingAnalyzer::Analyze(Trace &trace, const std::string &detType,
                              const std::string &detSubtype,
                              const std::map<std::string, int> & tagMap) {
    TraceAnalyzer::Analyze(trace, detType, detSubtype, tagMap);

    if(trace.HasValue("saturation") || trace.empty() ||
       trace.GetWaveform().size() == 0) {
        EndAnalyze();
        return;
    }

    Globals *globals = Globals::get();

    const double sigmaBaseline = trace.GetValue("sigmaBaseline");
    const double maxVal = trace.GetValue("maxval");
    const double qdc = trace.GetValue("qdc");
    const double maxPos = trace.GetValue("maxpos");
    const vector<double> waveform = trace.GetWaveform();
    bool isDblBeta = detType == "beta" && detSubtype == "double";
    bool isDblBetaT = isDblBeta && tagMap.find("timing") != tagMap.end();

    trace.plot(D_SIGMA, sigmaBaseline*100);

    if(!isDblBetaT) {
        if(sigmaBaseline > globals->sigmaBaselineThresh()) {
            EndAnalyze();
            return;
        }
    } else {
        if(sigmaBaseline > globals->siPmtSigmaBaselineThresh()) {
            EndAnalyze();
            return;
        }
    }

    pair<double,double> pars =  globals->fitPars(detType+":"+detSubtype);
    if(isDblBetaT)
        pars = globals->fitPars(detType+":"+detSubtype+":timing");

    FitDriver *driver;
    switch(fitterType_) {
        case FitDriver::GSL:
            driver = new GslFitter(isDblBetaT);
            break;
        case FitDriver::UNKNOWN:
        default:
            EndAnalyze();
            return;
    }

    driver->PerformFit(waveform, pars, sigmaBaseline, qdc);
    trace.InsertValue("phase", driver->GetPhase()+maxPos);

    trace.plot(DD_AMP, driver->GetAmplitude(), maxVal);
    trace.plot(D_PHASE, driver->GetPhase()*1000+100);
    trace.plot(D_CHISQPERDOF, driver->GetChiSqPerDof());

    delete(driver);
    EndAnalyze();
}

void TauAnalyzer::Analyze(Trace &trace, const std::string &aType,
                          const std::string &aSubtype,
                          const std::map<std::string, int> & tagMap) {
    // don't do analysis for piled-up traces
    if (trace.HasValue("filterEnergy2")) {
        return;
    }
    // only do analysis for the proper type and subtype
    if (type != "" && subtype != "" &&
        type != aType && subtype != aSubtype ) {
        return;
    }

    TraceAnalyzer::Analyze(trace, type, subtype);

    Trace::const_iterator itMax=max_element(trace.begin(), trace.end());
    Trace::const_iterator itMin=min_element(itMax, (Trace::const_iterator)trace.end());
    iterator_traits< Trace::const_iterator >::difference_type  size = distance(itMax, itMin);

    // skip over the area near the extrema since it may be non-exponential there
    advance(itMax, size/10);
    advance(itMin, -size/10);

    size = distance(itMax, itMin);
    double n = (double)size;

    double sum1=0, sum2=0;
    double i=0;
    for(Trace::const_iterator it=itMax; it != itMin; it++) {
            double j=i+1.;
            sum1 += double(*it)*(j*n*n-3*j*j*n+2*j*j*j);
            sum2 += double(*it)*(i*n*n-3*i*i*n+2*i*i*i);
            i+=1.;
    }
    double tau =  1 / log(sum1 / sum2) * Globals::get()->clockInSeconds();
    trace.SetValue("tau", tau);

    EndAnalyze();
}

void WaveformAnalyzer::Analyze(Trace &trace, const std::string &type,
                               const std::string &subtype,
                               const std::map<std::string, int> &tags) {
    TraceAnalyzer::Analyze(trace, type, subtype, tags);
    trc_ = &trace;

    if (trace.HasValue("saturation") || trace.size() == 0) {
        EndAnalyze();
        return;
    }

    mean_ = mval_ = 0;

    g_ = Globals::get();

    pair<unsigned int, unsigned int> range =
            g_->waveformRange(type + ":" + subtype);

    if (type == "beta" && subtype == "double" &&
        tags.find("timing") != tags.end())
        range = g_->waveformRange(type + ":" + subtype + ":timing");

    try {
        //First we find the waveform in the trace
        FindWaveform(range.first, range.second);
        //Calculate the baseline, need to know where waveform is before this point
        CalculateSums();
        //If we had something tagged for additional trace analysis.
        if (tags.find("psd") != tags.end())
            CalculateDiscrimination(g_->discriminationStart());
    } catch(WAVEFORMANALYZER_ERROR_CODES errorCode) {
        switch(errorCode) {
            case TOO_LOW:
                messenger_->warning("The low bound for the search was before "
                                            "the beginning of the trace. This"
                                            " is a bad thing, no trace "
                                            "analysis possible.", 0);
                break;
            case MAX_END:
                messenger_->warning("The maximum value of the trace was found"
                                            " at a point where your current "
                                            "waveform range will be outside "
                                            "of the trace. you should "
                                            "reevaluate the waveform range to"
                                            " make sure that you have set "
                                            "something reasonable. I suggest "
                                            "taking a look at the scope "
                                            "program to view the traces. ", 0);
                break;
            case LOW_GREATER_HIGH:
                messenger_->warning("The high bound for the waveform search "
                                            "was lower than the low bound. "
                                            "This should never have happened "
                                            "and I have no idea why it did.",
                                    0);
                break;
            default:
                stringstream ss;
                ss << "There was an unidentified error with an error code of "
                   << errorCode << ". Please review your settings for the "
                           "trace analysis.";
                messenger_->warning(ss.str(),0);
                break;
        }
        EndAnalyze();
    }
    EndAnalyze();
}

bool PspmtProcessor::PreProcess(RawEvent &event){
    if (!EventProcessor::PreProcess(event))
        return false;
    
    static const vector<ChanEvent*> &pspmtEvents = sumMap["pspmt"]->GetList();
    
    data_.Clear();
    
    double q1=0,q2=0,q3=0,q4=0,qd=0;
    double qdc1=0,qdc2=0,qdc3=0,qdc4=0,qdcd=0;
    double tre1=0,tre2=0,tre3=0,tre4=0,tred=0;
    
    double qright=0,qleft=0,qtop=0,qbottom=0,qsum=0;
    double xright=0,xleft=0,ytop=0,ybottom=0;
    
    double qtre_r=0,qtre_l=0,qtre_t=0,qtre_b=0,qtre_s=0;
    double xtre_r=0,xtre_l=0,ytre_t=0,ytre_b=0;
    
    double qqdc_r=0,qqdc_l=0,qqdc_t=0,qqdc_b=0,qqdc_s=0;
    double xqdc_r=0,xqdc_l=0,yqdc_t=0,yqdc_b=0;
    
    double pxright=0,pxleft=0,pytop=0,pybottom=0;
    double pxtre_r=0,pxtre_l=0,pytre_t=0,pytre_b=0;
    
    // tentatively local params //
    double threshold=260;
    double slope=0.0606;
    double intercept=10.13;
    //////////////////////////////
    static int traceNum;
    
    double f=0.1;
    
    for (vector<ChanEvent*>::const_iterator it = pspmtEvents.begin();
         it != pspmtEvents.end(); it++) {
        
        ChanEvent *chan   = *it;
        string subtype    = chan->GetChanID().GetSubtype();
        int    ch         = chan->GetChanID().GetLocation();
        double calEnergy  = chan->GetCalEnergy();
        //double pspmtTime  = chan->GetTime();
        Trace trace       = chan->GetTrace();
        
        double trace_energy;
        double trace_time;
        double baseline;
        double qdc;
        //int    num        = trace.GetValue("numPulses");
        
        if(trace.HasValue("filterEnergy")){
            traceNum++;   	  
            trace_time    = trace.GetValue("filterTime");
            trace_energy  = trace.GetValue("filterEnergy");
            baseline      = trace.DoBaseline(2,20);
            qdc             = trace.DoQDC(5,128);
            
            if(ch==0){
                qdc1 = qdc;
                tre1 = trace_energy;
                plot(D_QDC_TRACE1,qdc1);
                plot(D_ENERGY_TRACE1,tre1);
            }else if(ch==1){
                qdc2 = qdc;
                tre2 = trace_energy; 
                plot(D_QDC_TRACE2,qdc2);
                plot(D_ENERGY_TRACE2,tre2);
            }else if(ch==2){
                qdc3 = qdc;
                tre3 = trace_energy; 
                plot(D_QDC_TRACE3,qdc3);
                plot(D_ENERGY_TRACE3,tre3);
            }else if(ch==3){
                qdc4 = qdc;
                tre4 = trace_energy; 	  
                plot(D_QDC_TRACE4,qdc4);
                plot(D_ENERGY_TRACE4,tre4);
            }else if(ch==4){
                qdcd = qdc;
                tred = trace_energy; 
                plot(D_QDC_TRACED,qdcd);
                plot(D_ENERGY_TRACED,tred);
            }
        }

        if(ch==0){
            q1= calEnergy;
            plot(D_RAW1,q1);
        }else if(ch==1){
            q2= calEnergy;
            plot(D_RAW2,q2);
        }else if(ch==2){
            q3= calEnergy;
            plot(D_RAW3,q3);
        }else if(ch==3){
            q4= calEnergy;
            plot(D_RAW4,q4);
        }else if(ch==4){
            qd= calEnergy;
            plot(D_RAWD,qd);
        }
//.........这里部分代码省略.........