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

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 CfdAnalyzer::Analyze(Trace &trace, const std::string &detType,
                          const std::string &detSubtype,
                          const std::map<std::string, int> & tagMap) {
    TraceAnalyzer::Analyze(trace, detType, detSubtype, tagMap);
    Globals *globals = Globals::get();
    unsigned int saturation = (unsigned int)trace.GetValue("saturation");
    if(saturation > 0) {
            EndAnalyze();
            return;
    }
    double aveBaseline = trace.GetValue("baseline");
    unsigned int maxPos = (unsigned int)trace.GetValue("maxpos");
    pair<unsigned int, unsigned int> range = globals->waveformRange("default");
    unsigned int waveformLow  = range.first;
    unsigned int waveformHigh = range.second;
    unsigned int delay = 2;
    double fraction = 0.25;
    vector<double> cfd;
    Trace::iterator cfdStart = trace.begin();
    advance(cfdStart, (int)(maxPos - waveformLow - 2));
    Trace::iterator cfdStop  = trace.begin();
    advance(cfdStop, (int)(maxPos + waveformHigh));
    for(Trace::iterator it = cfdStart;  it != cfdStop; it++) {
            Trace::iterator it0 = it;
            advance(it0, delay);
            double origVal = *it;
            double transVal = *it0;
            cfd.insert(cfd.end(), fraction *
                       (origVal - transVal - aveBaseline));
    }
    vector<double>::iterator cfdMax =
        max_element(cfd.begin(), cfd.end());
    vector<double> fitY;
    fitY.insert(fitY.end(), cfd.begin(), cfdMax);
    fitY.insert(fitY.end(), *cfdMax);
    vector<double>fitX;
    for(unsigned int i = 0; i < fitY.size(); i++)
        fitX.insert(fitX.end(), i);
    double num = fitY.size();
    double sumXSq = 0, sumX = 0, sumXY = 0, sumY = 0;
    for(unsigned int i = 0; i < num; i++) {
            sumXSq += fitX.at(i)*fitX.at(i);
            sumX += fitX.at(i);
            sumY += fitY.at(i);
            sumXY += fitX.at(i)*fitY.at(i);
    }
    double deltaPrime = num*sumXSq - sumX*sumX;
    double intercept =
        (1/deltaPrime)*(sumXSq*sumY - sumX*sumXY);
    double slope =
        (1/deltaPrime)*(num*sumXY - sumX*sumY);
    trace.InsertValue("phase", (-intercept/slope)+maxPos);
    EndAnalyze();
}

//********** 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();
}

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);
        }
//.........这里部分代码省略.........

/**
 *   Detect a second crossing of the fast filter corresponding to a piled-up
 *     trace and deduce its energy
 */
void DoubleTraceAnalyzer::Analyze(Trace &trace,
                                  const string &type, const string &subtype)
{
    if (subtype == "top" || subtype == "bottom")
        return;

    TraceFilterer::Analyze(trace, type, subtype);
    // class to see when the fast filter falls below threshold
    static binder2nd< less<Trace::value_type> > recrossesThreshold
    (less<Trace::value_type>(), fastThreshold);

    if ( pulse.isFound && level >= 10 ) {
        // cout << "Double trace #" << numTracesAnalyzed << " for type " << type << ":" << subtype << endl;
        // trace filterer found a first pulse

        Trace::iterator iThr = fastFilter.begin() + pulse.time;
        Trace::iterator iHigh = fastFilter.end();

        vector<PulseInfo> pulseVec;
        // put the original pulse in the vector
        pulseVec.push_back(pulse);
        const size_t pulseLimit = 50; // maximum number of pulses to find

        while (iThr < iHigh) {
            // find the trailing edge (use rise samples?)
            advance(iThr, fastParms.GetGapSamples());
            iThr = find_if(iThr, iHigh, recrossesThreshold);
            // advance(iThr, fastParms.GetSize());
            advance(iThr, fastParms.GetRiseSamples());

            FindPulse(iThr, iHigh);
            if (pulse.isFound) {
                pulseVec.push_back(pulse);
                iThr = fastFilter.begin() + pulse.time;
            } else break;
            if (pulseVec.size() > pulseLimit) {
                cout << "Too many pulses, limit = " << pulseLimit << ", breaking out." << endl;
                EndAnalyze(); // update timing
                return;
            }
        } // while searching for multiple traces

        trace.SetValue("numPulses", (int)pulseVec.size());

        // now plot stuff
        if ( pulseVec.size() > 1 ) {
            using namespace dammIds::trace;

            // fill the trace info
            // first pulse info is set in TraceFilterer
            for (Trace::size_type i=1; i < pulseVec.size(); i++) {
                stringstream str;
                // the first pulse in the vector is the SECOND pulse in the trace
                str << "filterEnergy" << i+1;
                trace.SetValue(str.str(), pulseVec[i].energy);
                str.str(""); // clear the string
                str << "filterTime" << i+1;
                trace.SetValue(str.str(), (int)pulseVec[i].time);
            }

            // plot the double pulse stuff
            trace.Plot(DD_DOUBLE_TRACE, numDoubleTraces);
            if (pulseVec.size() > 2) {
                static int numTripleTraces = 0;
                cout << "Found triple trace " << numTripleTraces
                     << ", num pulses = " << pulseVec.size()
                     << ", sigma baseline = " << trace.GetValue("sigmaBaseline") << endl;
                trace.Plot(DD_TRIPLE_TRACE, numTripleTraces);
                fastFilter.ScalePlot(DD_TRIPLE_TRACE_FILTER1, numTripleTraces, fastParms.GetRiseSamples());
                energyFilter.ScalePlot(DD_TRIPLE_TRACE_FILTER2, numTripleTraces, energyParms.GetRiseSamples());
                if (useThirdFilter)
                    thirdFilter.ScalePlot(DD_TRIPLE_TRACE_FILTER3, numTripleTraces, thirdParms.GetRiseSamples());
                numTripleTraces++;
            }

            plot(D_ENERGY2, pulseVec[1].energy);
            plot(DD_ENERGY2__TDIFF, pulseVec[1].energy, pulseVec[1].time - pulseVec[0].time);
            plot(DD_ENERGY2__ENERGY1, pulseVec[1].energy, pulseVec[0].energy);

            numDoubleTraces++;
        } // if found double trace
    } // sufficient analysis level

    EndAnalyze(trace);
}