/search.css" rel="stylesheet" type="text/css"/> /search.js">
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

In This Package:

Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes
AdUnfoldTool Class Reference

#include <AdUnfoldTool.h>

Inheritance diagram for AdUnfoldTool:
Inheritance graph
[legend]
Collaboration diagram for AdUnfoldTool:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 AdUnfoldTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual ~AdUnfoldTool ()
virtual StatusCode reconstruct (const DayaBay::CalibReadout &readout, DayaBay::RecTrigger &recTrigger)
virtual StatusCode initialize ()
virtual StatusCode finalize ()

Static Public Member Functions

static const InterfaceID & interfaceID ()

Private Member Functions

void PMTLinearityCorrection (const DayaBay::CalibReadout &readout, Int_t ch, Double_t observedCharge, Double_t &expectedCharge)
void UnfoldingSPUNIT (Int_t nIteration, const TMatrixD &matrix, const TVectorD &response, Double_t profile0, TVectorD &profile)
void SolveEnergyProfile (Int_t nIteration, const TMatrixD &matrix, const TVectorD &response, Double_t profile0, TVectorD &profile, Double_t *chisquare=0)
StatusCode RpcPointToAdLocal (const DayaBay::CalibReadout &readout, Gaudi::XYZPoint &rpcPoint)
void WeightedLeastSquaresRegression (Int_t nPoint, const std::vector< Double_t > &x, const std::vector< Double_t > &y, const std::vector< Double_t > &weight, Double_t &slope, Double_t &intercept, Double_t &slopeError, Double_t &interceptError)
void GoodnessOfFit (Int_t nPoint, const std::vector< Double_t > &x, const std::vector< Double_t > &y, const std::vector< Double_t > &z, const std::vector< Double_t > &weight, Double_t slopeX, Double_t interceptX, Double_t slopeY, Double_t interceptY, Double_t &chisquare, Double_t &rsquare)
void LinearRegression (Int_t nPoint, const std::vector< TVectorD > &pointsAd, const std::vector< TVectorD > &pointsRpc, Double_t &slopeX, Double_t &interceptX, Double_t &slopeY, Double_t &interceptY, Double_t &slopeErrorX, Double_t &interceptErrorX, Double_t &slopeErrorY, Double_t &interceptErrorY, Double_t &chisquare, Double_t &rsquare)
void DirectionBiasCorrection (Double_t rsquare, Double_t &dx, Double_t &dy, Double_t &dz, Double_t &dxErr, Double_t &dyErr, Double_t &dzErr)
Double_t TrackLengthInCylinder (Double_t targetH, Double_t targetD, Double_t vx, Double_t vy, Double_t vz, Double_t dx, Double_t dy, Double_t dz)
void DiagnosticPlot (const DayaBay::CalibReadout &readout, const Char_t *name, const Char_t *title, const std::vector< TVectorD > &profile, Int_t nGroup=0)

Private Attributes

std::string m_cableSvcName
ICableSvcm_cableSvc
std::string m_calibDataSvcName
IPmtCalibSvcm_calibDataSvc
std::string m_recDataSvcName
IDetCalibSvcm_recDataSvc
std::string m_detDataSvcName
IDataProviderSvc * m_detDataSvc
Int_t m_linearityMode
std::string m_filenameLinearity
std::string m_filenameMatrix
Int_t m_reconNGroupSample1
Int_t m_reconNGroupSample2
Int_t m_reconNTournament
Int_t m_reconNIterUnfold
Int_t m_reconNVertexPoint
Int_t m_reconNTrackPoint
Float_t m_chargeThreshold
Float_t m_lsLightYield
Int_t m_randomSeed
Int_t m_diagnosticMode
std::string m_rpcRecHeaderLocation
Int_t m_rpcMaxNCluster
Double_t m_linearityPar [kNSite][kSiteMaxNAd][kAdPmtNChannel][kLinearityNPar]
Int_t m_reconNGroup
std::vector< TVectorD > m_groupList
TMatrixD m_responseMatrix
TMatrixD m_distanceMap
Double_t m_profile0Factor
TRandom3 m_random
Double_t m_rpcTriggerTime
std::vector< const
DayaBay::RecRpcCluster * > 
m_rpcClusters
std::map< Site::Site_t,
Gaudi::XYZPoint > 
m_rpcRecOffset
TFile * m_diagnosticFile
clock_t m_clockElapsed
Float_t m_timeElapsed
Int_t m_nEventTotal
Int_t m_nEventProcessed
Int_t m_nEventSkipped

Detailed Description

Definition at line 98 of file AdUnfoldTool.h.


Constructor & Destructor Documentation

AdUnfoldTool::AdUnfoldTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 42 of file AdUnfoldTool.cc.

  : GaudiTool(type, name, parent), m_cableSvc(0), m_calibDataSvc(0), m_recDataSvc(0)
{
    declareInterface<IReconTool>(this);
    declareProperty("CableSvcName", m_cableSvcName = "CableSvc",
                    "Name of service to map between detector, hardware, and electronic IDs");
    declareProperty("CalibDataSvcName", m_calibDataSvcName = "DybPmtCalibSvc",
                    "Name of calibration data service");
    declareProperty("RecDataSvcName", m_recDataSvcName = "DybDetCalibSvc",
                    "Name of calibration data service");
    declareProperty("DetDataSvcName", m_detDataSvcName = "DetectorDataSvc",
                    "Name of detector data service");

    declareProperty("LinearityMode", m_linearityMode = kLinearityMode,
                    "Linearity correction mode");
    declareProperty("FilenameLinearity", m_filenameLinearity = "",
                    "Linearity correction parameter filename");
    declareProperty("FilenameMatrix", m_filenameMatrix = "",
                    "Response matrix filename");
    declareProperty("ReconNGroupSample1", m_reconNGroupSample1 = kReconNGroupSample1,
                    "Number of groups in the energy profile sample (1st pass: initial guess)");
    declareProperty("ReconNGroupSample2", m_reconNGroupSample2 = kReconNGroupSample2,
                    "Number of groups in the energy profile sample (2nd pass: refinement)");
    declareProperty("ReconNTournament", m_reconNTournament = kReconNTournament,
                    "Number of binary tournaments in the sampling of energy groups");
    declareProperty("ReconNIterUnfold", m_reconNIterUnfold = kReconNIterUnfold,
                    "Number of iterations in the unfolding of energy profile");
    declareProperty("ReconNVertexPoint", m_reconNVertexPoint = kReconNVertexPoint,
                    "Number of points in the vertex reconstruction");
    declareProperty("ReconNTrackPoint", m_reconNTrackPoint = kReconNTrackPoint,
                    "Number of points in the linear regression");
    declareProperty("ChargeThreshold", m_chargeThreshold = kChargeThreshold,
                    "Threshold of nominal charge to reconstruct an event");
    declareProperty("LsLightYield", m_lsLightYield = kLsLightYield,
                    "LS light yield, for energy calibration");
    declareProperty("RandomSeed", m_randomSeed = 0,
                    "Random seed");
    declareProperty("DiagnosticMode", m_diagnosticMode = 0,
                    "Diagnostic mode");

    declareProperty("RpcRecHeaderLocation", m_rpcRecHeaderLocation = kRpcRecHeaderLocation,
                    "RPC RecHeader location");
    declareProperty("RpcMaxNCluster", m_rpcMaxNCluster = kRpcMaxNCluster,
                    "Maximum number of RPC clusters in the linear regression");
}
AdUnfoldTool::~AdUnfoldTool ( ) [virtual]

Definition at line 90 of file AdUnfoldTool.cc.

{
}

Member Function Documentation

StatusCode AdUnfoldTool::reconstruct ( const DayaBay::CalibReadout readout,
DayaBay::RecTrigger recTrigger 
) [virtual]

Implements IReconTool.

Definition at line 294 of file AdUnfoldTool.cc.

{
    clock_t clockStart = clock();
    m_nEventTotal++;

    // Retrieve RPC hits
    if ((m_rpcMaxNCluster > 0) && (readout.detector().isRPC())) {
        m_rpcTriggerTime = readout.triggerTime().GetSeconds();

        if (!exist<DayaBay::RecRpcHeader>(evtSvc(), m_rpcRecHeaderLocation)) {
            warning() << "Cannot find header at " << m_rpcRecHeaderLocation << endreq;
            m_rpcClusters.clear();
        } else {
            const DayaBay::RecRpcHeader *rpcRecHdr = get<DayaBay::RecRpcHeader>(m_rpcRecHeaderLocation);
            m_rpcClusters = rpcRecHdr->recTrigger().clusters();
        }
    }

    if (!readout.detector().isAD()) {
        debug() << "Not an AD readout; ignoring detector "
                << readout.detector().detName() << endreq;
        recTrigger.setPositionStatus(ReconStatus::kNotProcessed);
        recTrigger.setDirectionStatus(ReconStatus::kNotProcessed);
        recTrigger.setEnergyStatus(ReconStatus::kNotProcessed);
        m_clockElapsed += clock() - clockStart;

        return StatusCode::SUCCESS;
    }

    const CalibReadoutPmtCrate *pmtReadout = dynamic_cast<const CalibReadoutPmtCrate*>(&readout);
    if (!pmtReadout) {
        error() << "Incorrect type of readout crate for detector "
                << readout.detector().detName() << endreq;
        recTrigger.setPositionStatus(ReconStatus::kBadReadout);
        recTrigger.setDirectionStatus(ReconStatus::kBadReadout);
        recTrigger.setEnergyStatus(ReconStatus::kBadReadout);
        m_clockElapsed += clock() - clockStart;

        return StatusCode::FAILURE;
    }

    // Context for this data
    // Note: use task = 0 when looking up PMT status
    Int_t task_pmt = 0;
    ServiceMode svcMode_pmt(readout.header()->context(), task_pmt);
    // Note: use task = 0 for Co60, and task = 1 for spallation neutron energy scale
    Int_t task_rec = 1;
    ServiceMode svcMode_rec(readout.header()->context(), task_rec);

    // Loop over hits
    Double_t qSum = 0.0;
    Double_t time = 0.0;
    Int_t nHits = 0;
    TVectorD response(kAdPmtNChannel);
    CalibReadoutPmtCrate::PmtChannelReadouts::const_iterator chIter, chBegin, chEnd;

    chBegin = pmtReadout->channelReadout().begin();
    chEnd = pmtReadout->channelReadout().end();

    for (chIter = chBegin; chIter != chEnd; chIter++) {
        const CalibReadoutPmtChannel &channel = *chIter;

        AdPmtSensor pmtId(channel.pmtSensorId().fullPackedData());
        if (!pmtId.is8inch())   // Ignore non 8-inch pmt channels
            continue;

        const PmtCalibData *pmtCalib = m_calibDataSvc->pmtCalibData(pmtId, svcMode_pmt);
        if (!pmtCalib) {
            error() << "No calibration data for pmt ID: " << pmtId << endreq;
            recTrigger.setPositionStatus(ReconStatus::kBadReadout);
            recTrigger.setDirectionStatus(ReconStatus::kBadReadout);
            recTrigger.setEnergyStatus(ReconStatus::kBadReadout);
            m_clockElapsed += clock() - clockStart;

            return StatusCode::FAILURE;
        }
        if (pmtCalib->m_status != PmtCalibData::kGood)
            continue;

        Double_t peakAdc = channel.earliestCharge(kEarliestChargeTime, kLatestChargeTime);

        if (peakAdc > 0.0) {
            Int_t ch = kAdPmtNColumn * (pmtId.ring()-1) + (pmtId.column()-1);
            Double_t expectedCharge;

            PMTLinearityCorrection(readout, ch, peakAdc, expectedCharge);

            response[ch] = expectedCharge;
            qSum += expectedCharge;
            time += expectedCharge * channel.earliestTime();
            nHits++;
        }
    }

    if (qSum > 0.0)
        time /= qSum;

    if (nHits < 1) {
        recTrigger.setPositionStatus(ReconStatus::kNoHits);
        recTrigger.setDirectionStatus(ReconStatus::kNoHits);
        recTrigger.setEnergyStatus(ReconStatus::kNoHits);
        m_clockElapsed += clock() - clockStart;

        return StatusCode::SUCCESS;
    }
    if (qSum < m_chargeThreshold) {
        recTrigger.setPositionStatus(ReconStatus::kNotProcessed);
        recTrigger.setDirectionStatus(ReconStatus::kNotProcessed);
        recTrigger.setEnergyStatus(ReconStatus::kNotProcessed);
        m_clockElapsed += clock() - clockStart;

        return StatusCode::SUCCESS;
    }

    // Reconstruct energy deposition profile
    Double_t chi2 = 0.0;

    // Unfolding 1st pass: initial guess
    std::vector<Bool_t> isGroupSelected1(m_reconNGroup, kFALSE);
    std::vector<Int_t> groupIdx1(m_reconNGroupSample1, 0);
    TMatrixD responseMatrix1(kAdPmtNChannel, m_reconNGroupSample1);
    TVectorD energyProfile1(m_reconNGroupSample1);

    for (Int_t i = 0; i < m_reconNGroupSample1; i++) {
        Int_t groupIdx;

        do {
            groupIdx = m_random.Integer(m_reconNGroup);
        } while (isGroupSelected1[groupIdx]);

        groupIdx1[i] = groupIdx;

        for (Int_t j = 0; j < kAdPmtNChannel; j++)
            responseMatrix1[j][i] = m_responseMatrix[j][groupIdx];

        isGroupSelected1[groupIdx] = kTRUE;
    }

    SolveEnergyProfile(m_reconNIterUnfold, responseMatrix1, response, qSum*m_profile0Factor, energyProfile1);

    // Unfolding 2nd pass: refinement
    std::vector<Bool_t> isGroupSelected2(m_reconNGroup, kFALSE);
    std::vector<Int_t> groupIdx2(m_reconNGroupSample2, 0);
    TMatrixD responseMatrix2(kAdPmtNChannel, m_reconNGroupSample2);
    TVectorD energyProfile2(m_reconNGroupSample2);

    for (Int_t i = 0; i < m_reconNGroupSample2; i++) {
        Int_t groupIdx = 0;
        Double_t groupE = 0.0;

        for (Int_t j = 0; j <= m_reconNTournament; j++) {
            Int_t groupIdx_tmp;
            Double_t groupE_tmp;

            do {
                groupIdx_tmp = m_random.Integer(m_reconNGroup);
            } while (isGroupSelected2[groupIdx_tmp]);

            Double_t sumW = 0.0, sumWE = 0.0;

            for (Int_t k = 0; k < m_reconNGroupSample1; k++) {
                Double_t distance = m_distanceMap[groupIdx_tmp][groupIdx1[k]];

                if (distance > 0.0) {
                    Double_t W = 1.0 / (distance*distance);

                    sumW += W;
                    sumWE += W * energyProfile1[k];
                } else {
                    sumW = 1.0;
                    sumWE = energyProfile1[k];

                    break;
                }
            }

            groupE_tmp = sumWE / sumW;

            if (groupE_tmp > groupE) {
                groupIdx = groupIdx_tmp;
                groupE = groupE_tmp;
            }
        }

        groupIdx2[i] = groupIdx;

        for (Int_t j = 0; j < kAdPmtNChannel; j++)
            responseMatrix2[j][i] = m_responseMatrix[j][groupIdx];

        energyProfile2[i] = groupE * m_reconNGroupSample1 / m_reconNGroupSample2;

        isGroupSelected2[groupIdx] = kTRUE;
    }

    SolveEnergyProfile(m_reconNIterUnfold, responseMatrix2, response, 0.0, energyProfile2, &chi2);

    // Summarize the reconstructed energy deposition profile
    std::vector<TVectorD> energyProfile;
    Int_t energyProfileSize;
    Double_t energyScaleFactor = 1.0;

    const DayaBay::DetEnergyReconData* energyScale = m_recDataSvc->detEnergyReconData(svcMode_rec);
    if (!energyScale)
        warning() << "No energy scale found in DB for context " << readout.header()->context().AsString() << " and task " << task_rec << endreq;
    else
        energyScaleFactor *= 170.0 / energyScale->m_PeEvis;

    if (m_reconNGroupSample2 > 0) {
        for (Int_t i = 0; i < m_reconNGroupSample2; i++) {
            TVectorD group(4);

            group = m_groupList[groupIdx2[i]];
            group[3] = energyProfile2[i] * energyScaleFactor / m_lsLightYield;
            energyProfile.push_back(group);
        }
    } else {
        for (Int_t i = 0; i < m_reconNGroupSample1; i++) {
            TVectorD group(4);

            group = m_groupList[groupIdx1[i]];
            group[3] = energyProfile1[i] * energyScaleFactor / m_lsLightYield;
            energyProfile.push_back(group);
        }
    }

    std::sort(energyProfile.begin(), energyProfile.end(), CompareEnergy);

    energyProfileSize = energyProfile.size();

    // Energy reconstruction
    Double_t rawEvis = qSum * energyScaleFactor / 170.0;
    Double_t energy = 0.0, energyErr;

    for (Int_t i = 0; i < energyProfileSize; i++)
        energy += energyProfile[i][3];    

    energyErr = energy / TMath::Sqrt(qSum);

    recTrigger.setRawEvis(rawEvis);
    recTrigger.setEnergy(energy);
    recTrigger.setEnergyQuality(chi2);
    recTrigger.setEnergyStatus(ReconStatus::kGood);

    DiagnosticPlot(readout, "energy", "Energy profile", energyProfile);

    // Vertex reconstruction
    Double_t sumE = 0.0, sumEX = 0.0, sumEY = 0.0, sumEZ = 0.0;
    Double_t sumEX2 = 0.0, sumEY2 = 0.0, sumEZ2 = 0.0;

    for (Int_t i = 0; i < m_reconNVertexPoint; i++) {
        Double_t X = energyProfile[i][0];
        Double_t Y = energyProfile[i][1];
        Double_t Z = energyProfile[i][2];
        Double_t E = energyProfile[i][3];
        Double_t EX = E * X;
        Double_t EY = E * Y;
        Double_t EZ = E * Z;

        sumE += E;
        sumEX += EX;
        sumEY += EY;
        sumEZ += EZ;
        sumEX2 += EX * X;
        sumEY2 += EY * Y;
        sumEZ2 += EZ * Z;
    }

    Double_t x = sumEX / sumE;
    Double_t y = sumEY / sumE;
    Double_t z = sumEZ / sumE;
    Double_t xErr = TMath::Sqrt((sumEX2/sumE - x*x) / m_reconNVertexPoint);
    Double_t yErr = TMath::Sqrt((sumEY2/sumE - y*y) / m_reconNVertexPoint);
    Double_t zErr = TMath::Sqrt((sumEZ2/sumE - z*z) / m_reconNVertexPoint);

    CLHEP::HepLorentzVector position(x, y, z, time);
    recTrigger.setPosition(position);
    recTrigger.setPositionQuality(chi2);
    recTrigger.setPositionStatus(ReconStatus::kGood);

    DiagnosticPlot(readout, "vertex", "Vertex sample", energyProfile, m_reconNVertexPoint);

    // Track reconstruction
    Double_t mX = 0.0, cX = 0.0, mY = 0.0, cY = 0.0;
    Double_t mErrX = 0.0, cErrX = 0.0, mErrY = 0.0, cErrY = 0.0;
    Double_t chisquare = -1, r2 = 0.0;
    Double_t triggerTimeAfterRpc = readout.triggerTime().GetSeconds() - m_rpcTriggerTime;
    std::vector<TVectorD> pointsRpc;
    Bool_t isRpcSelected = kFALSE;

    if ((m_rpcMaxNCluster > 0) && (triggerTimeAfterRpc < kRpcCoincidenceTime)) {
        if ((Int_t)m_rpcClusters.size() <= m_rpcMaxNCluster) {
            for (Int_t i = 0; i < (Int_t)m_rpcClusters.size(); i++) {
                const CLHEP::HepLorentzVector &rpcVector = m_rpcClusters[i]->position();
                Gaudi::XYZPoint rpcPoint(rpcVector.x(), rpcVector.y(), rpcVector.z());
                TVectorD group(4);

                rpcPoint = rpcPoint - m_rpcRecOffset[readout.detector().site()];
                if (RpcPointToAdLocal(readout, rpcPoint) != StatusCode::SUCCESS) {
                    warning() << "Cannot transform RPC cluster position to AD local coordinates" << endreq;
                    continue;
                }

                group[0] = rpcPoint.X();
                group[1] = rpcPoint.Y();
                group[2] = rpcPoint.Z();
                group[3] = rawEvis;
                pointsRpc.push_back(group);

                isRpcSelected = kTRUE;
            }
        }
    }

    LinearRegression(m_reconNTrackPoint, energyProfile, pointsRpc,
                     mX, cX, mY, cY, mErrX, cErrX, mErrY, cErrY, chisquare, r2);

    Double_t normalization = -1.0 / TMath::Sqrt(mX*mX + mY*mY + 1.0);
    Double_t dx = mX * normalization;
    Double_t dy = mY * normalization;
    Double_t dz = normalization;
    Double_t dxErr = TMath::Abs(mErrX * normalization);
    Double_t dyErr = TMath::Abs(mErrY * normalization);
    Double_t dzErr = 0.0;

    if (!isRpcSelected)
        DirectionBiasCorrection(r2, dx, dy, dz, dxErr, dyErr, dzErr);

    Double_t trackLength = TrackLengthInCylinder(kAdAv4Height, kAdAv4Diameter,
                                                 x, y, z, dx, dy, dz);

    CLHEP::HepLorentzVector direction(dx, dy, dz, trackLength);
    recTrigger.setDirection(direction);
    recTrigger.setDirectionQuality(r2);
    recTrigger.setDirectionStatus(ReconStatus::kGood);

    DiagnosticPlot(readout, "track", "Track sample", energyProfile, m_reconNTrackPoint);

    // Reconstruction error
    const Int_t errorMatrixDim = 7;
    CLHEP::HepMatrix errorMatrix(errorMatrixDim, errorMatrixDim);
    errorMatrix[0][0] = energyErr;      // Energy uncertainty
    errorMatrix[1][1] = xErr;           // x uncertainty
    errorMatrix[2][2] = yErr;           // y uncertainty
    errorMatrix[3][3] = zErr;           // z uncertainty
    errorMatrix[4][4] = dxErr;          // dx uncertainty
    errorMatrix[5][5] = dyErr;          // dy uncertainty
    errorMatrix[6][6] = dzErr;          // dz uncertainty
    recTrigger.setErrorMatrix(errorMatrix);

    m_clockElapsed += clock() - clockStart;
    m_nEventProcessed++;

    return StatusCode::SUCCESS;
}
StatusCode AdUnfoldTool::initialize ( ) [virtual]

Definition at line 94 of file AdUnfoldTool.cc.

{
    // Get services
    m_cableSvc = svc<ICableSvc>(m_cableSvcName, kTRUE);
    m_calibDataSvc = svc<IPmtCalibSvc>(m_calibDataSvcName, kTRUE);
    m_recDataSvc = svc<IDetCalibSvc>(m_recDataSvcName, kTRUE);
    m_detDataSvc = svc<IDataProviderSvc>(m_detDataSvcName, kTRUE);

    info() << "Initializing AdUnfold event reconstruction module" << endreq;

    ifstream fin;

    if (m_linearityMode == 2) {
        // Open linearity correction parameter data file
        Char_t *filenameLinearity;

        if (m_filenameLinearity == "")
            filenameLinearity = Form("%s/data_files/%s", getenv("ADUNFOLDROOT"), kFilenameLinearity.c_str());
        else
            filenameLinearity = Form("%s", m_filenameLinearity.c_str());

        fin.open(filenameLinearity);
        if (!fin.is_open()) {
            error() << "Cannot open linearity correction parameter file: " << filenameLinearity << endreq;

            return StatusCode::FAILURE;
        }

        // Read linearity correction parameters
        Bool_t isLinearityValid = kTRUE;
        Char_t dummy_str[256];

        fin >> dummy_str >> dummy_str >> dummy_str >> dummy_str >> dummy_str;
        for (Int_t i = 0; i < kLinearityNPar; i++)
            fin >> dummy_str >> dummy_str;
        for (Int_t site = 0; site < kNSite; site++) {
            Int_t siteNAd;
            if (site <= 1)
                siteNAd = 2;
            else
                siteNAd = 4;

            for (Int_t ad = 0; ad < siteNAd; ad++)
                for (Int_t ch = 0; ch < kAdPmtNChannel; ch++) {
                    Int_t site_read, ad_read, ch_read;
                    Double_t chi2_read, ndf_read;

                    fin >> site_read >> ad_read >> ch_read >> chi2_read >> ndf_read;
                    if (site_read != site+1)
                        isLinearityValid = kFALSE;
                    if (ad_read != ad+1)
                        isLinearityValid = kFALSE;
                    if (ch_read != ch)
                        isLinearityValid = kFALSE;

                    for (Int_t par = 0; par < kLinearityNPar; par++) {
                        Double_t par_read, par_err_read;

                        fin >> par_read >> par_err_read;
                        m_linearityPar[site][ad][ch][par] = par_read;
                    }
                }
        }

        if (!isLinearityValid) {
            error() << "Invalid linearity correction parameter(s)" << endreq;

            return StatusCode::FAILURE;
        }

        fin.close();

        info() << "Loaded linearity correction parameter file: " << filenameLinearity << endreq;
    }

    // Open response matrix data file
    Char_t *filenameMatrix;

    if (m_filenameMatrix == "")
        filenameMatrix = Form("%s/data_files/%s", getenv("ADUNFOLDROOT"), kFilenameMatrix.c_str());
    else
        filenameMatrix = Form("%s", m_filenameMatrix.c_str());

    fin.open(filenameMatrix);
    if (!fin.is_open()) {
        error() << "Cannot open response matrix file: " << filenameMatrix << endreq;

        return StatusCode::FAILURE;
    }

    fin >> m_reconNGroup;

    // Check parameters
    Bool_t isParamValid = kTRUE;

    if ((m_reconNGroupSample1 <= 0) || (m_reconNGroupSample1 > m_reconNGroup))
        isParamValid = kFALSE;
    if ((m_reconNGroupSample2 < 0) || (m_reconNGroupSample2 > m_reconNGroup))
        isParamValid = kFALSE;
    if (m_reconNGroupSample2 <= 0) {
        if ((m_reconNVertexPoint <= 0) || (m_reconNVertexPoint > m_reconNGroupSample1))
            isParamValid = kFALSE;
        if ((m_reconNTrackPoint <= 0) || (m_reconNTrackPoint > m_reconNGroupSample1))
            isParamValid = kFALSE;
    } else {
        if ((m_reconNVertexPoint <= 0) || (m_reconNVertexPoint > m_reconNGroupSample2))
            isParamValid = kFALSE;
        if ((m_reconNTrackPoint <= 0) || (m_reconNTrackPoint > m_reconNGroupSample2))
            isParamValid = kFALSE;
    }
    if (m_reconNTournament <= 0)
        isParamValid = kFALSE;
    if (m_reconNIterUnfold <= 0)
        isParamValid = kFALSE;
    if (m_lsLightYield <= 0.0)
        isParamValid = kFALSE;
    if (!isParamValid) {
        error() << "Invalid reconstruction parameter(s)" << endreq;

        return StatusCode::FAILURE;
    }

    // Read response matrix
    m_responseMatrix.ResizeTo(kAdPmtNChannel, m_reconNGroup);

    for (Int_t i = 0; i < m_reconNGroup; i++) {
        TVectorD group(4);

        fin >> group[0] >> group[1] >> group[2];
        m_groupList.push_back(group);
    }
    for (Int_t i = 0; i < kAdPmtNChannel; i++)
        for (Int_t j = 0; j < m_reconNGroup; j++)
            fin >> m_responseMatrix[i][j];

    fin.close();

    info() << "Loaded response matrix file: " << filenameMatrix << endreq;

    // Pre-calculate the distance between each group
    m_distanceMap.ResizeTo(m_reconNGroup, m_reconNGroup);

    for (Int_t i = 0; i < m_reconNGroup; i++)
        for (Int_t j = 0; j < m_reconNGroup; j++) {
            Double_t dx = m_groupList[i][0] - m_groupList[j][0];
            Double_t dy = m_groupList[i][1] - m_groupList[j][1];
            Double_t dz = m_groupList[i][2] - m_groupList[j][2];

            m_distanceMap[i][j] = TMath::Sqrt(dx*dx + dy*dy + dz*dz);
        }

    // Pre-calculate profile0 common factor
    m_profile0Factor = 1.0 / m_responseMatrix.Sum();
    m_profile0Factor *= m_reconNGroup / m_reconNGroupSample1;

    // Assign random seed
    m_random.SetSeed(m_randomSeed);

    // Store RPC reconstruction offset
    m_rpcRecOffset[Site::kDayaBay] = Gaudi::XYZPoint(2500.0, -500.0, 12500.0);
    m_rpcRecOffset[Site::kLingAo] = Gaudi::XYZPoint(2500.0, -500.0, 12500.0);
    m_rpcRecOffset[Site::kFar] = Gaudi::XYZPoint(5650.0, 500.0, 12500.0);

    // Create diagnostic file
    if (m_diagnosticMode > 0)
        m_diagnosticFile = new TFile(Form("adunfold_diagnostic_%d.root", time(NULL)), "NEW");

    // Reset event reconstruction summary
    m_clockElapsed = 0;
    m_nEventTotal = 0;
    m_nEventProcessed = 0;

    return StatusCode::SUCCESS;
}
StatusCode AdUnfoldTool::finalize ( ) [virtual]

Definition at line 269 of file AdUnfoldTool.cc.

{
    // Close diagnostic file
    if (m_diagnosticMode > 0) {
        m_diagnosticFile->Write();
        m_diagnosticFile->Close();
    }

    // Event reconstruction summary
    m_timeElapsed = (Float_t)m_clockElapsed / CLOCKS_PER_SEC;
    m_nEventSkipped = m_nEventTotal - m_nEventProcessed;

    info() << "AdUnfold event reconstruction summary: "
           << "time elapsed=" << m_timeElapsed << ", "
           << "events processed=" << m_nEventProcessed << ", "
           << "events skipped=" << m_nEventSkipped << endreq;

    return StatusCode::SUCCESS;
}
void AdUnfoldTool::PMTLinearityCorrection ( const DayaBay::CalibReadout readout,
Int_t  ch,
Double_t  observedCharge,
Double_t &  expectedCharge 
) [inline, private]

Definition at line 650 of file AdUnfoldTool.cc.

{
    if (m_linearityMode == 1) {
        Double_t q1 = observedCharge;
        Double_t q2 = q1 * q1;
        Double_t q3 = q1 * q2;
        Double_t q4 = q2 * q2;

        if (observedCharge < 360.0)
            expectedCharge = 1.00336*q1 + 1.82058e-05*q2;
        else if (observedCharge < 1800.0)
            expectedCharge = 110.131 + 0.181365*q1 + 0.00175068*q2 - 9.08761e-07*q3 + 1.65924e-10*q4;
        else
            expectedCharge = -151.785 + 1.50015*q1;
    }
    else
    if (m_linearityMode == 2) {
        Int_t site = 0;
        Int_t ad = readout.detector().detectorId() - 1;
        if (readout.detector().site() == Site::kDayaBay)
            site = 0;
        else
        if (readout.detector().site() == Site::kLingAo)
            site = 1;
        else
        if (readout.detector().site() == Site::kFar)
            site = 2;

        Double_t p0 = m_linearityPar[site][ad][ch][0];  // Offset
        Double_t p1 = m_linearityPar[site][ad][ch][1];  // Gain - fine range
        Double_t p2 = m_linearityPar[site][ad][ch][2];  // Gain - coarse range lower
        Double_t p3 = m_linearityPar[site][ad][ch][3];  // Gain - coarse range upper
        Double_t p4 = m_linearityPar[site][ad][ch][4];  // Transition from fine to coarse
        Double_t p5 = m_linearityPar[site][ad][ch][5];  // Transition in coarse range

        if ((p1 == 0.0) || (observedCharge < p4))
            expectedCharge = observedCharge;
        else
        if (observedCharge < p5)
            expectedCharge = (p2/p1)*(observedCharge-p4) + p4;
        else
            expectedCharge = (p3/p1)*(observedCharge-p5) + (p2/p1)*(p5-p4) + p4;
    }
    else
        expectedCharge = observedCharge;
}
void AdUnfoldTool::UnfoldingSPUNIT ( Int_t  nIteration,
const TMatrixD &  matrix,
const TVectorD &  response,
Double_t  profile0,
TVectorD &  profile 
) [private]

Definition at line 698 of file AdUnfoldTool.cc.

{
    Int_t nResponse = matrix.GetNrows();
    Int_t nGroup = matrix.GetNcols();

    if (nGroup == 0) return;

    TVectorD Profile(nGroup);

    if (profile0 == 0.0)
        Profile = profile;
    else
        Profile = profile0;

    // Calculate the normalization constants
    TMatrixD W(nGroup, nResponse);
    TVectorD WSum(nGroup);

    for (Int_t i = 0; i < nResponse; i++) {
        if (response[i] <= 0.0)
            continue;

        for (Int_t j = 0; j < nGroup; j++) {
            W[j][i] = matrix[i][j];
            WSum[j] += W[j][i];
        }
    }

    // Unfolding the profile
    for (Int_t iter = 0; iter < nIteration; iter++) {
        TVectorD Z(nResponse), ZRatio(nResponse);
        TVectorD WZSum(nGroup);

        Z = matrix * Profile;

        for (Int_t i = 0; i < nResponse; i++)
            ZRatio[i] = response[i] / Z[i];

        WZSum = W * ZRatio;

        for (Int_t i = 0; i < nGroup; i++)
            Profile[i] *= WZSum[i] / WSum[i];
    }

    profile.ResizeTo(nGroup);
    profile = Profile;
}
void AdUnfoldTool::SolveEnergyProfile ( Int_t  nIteration,
const TMatrixD &  matrix,
const TVectorD &  response,
Double_t  profile0,
TVectorD &  profile,
Double_t *  chisquare = 0 
) [private]

Definition at line 747 of file AdUnfoldTool.cc.

{
    UnfoldingSPUNIT(nIteration, matrix, response, profile0, profile);

    // Calculate the chi-squares
    if (chisquare != NULL) {
        Int_t nResponse = matrix.GetNrows();
        TVectorD Z(nResponse), ZDiff(nResponse);
        Int_t nActiveChannel = 0;
        *chisquare = 0.0;

        Z = matrix * profile;
        ZDiff = response - Z;

        for (Int_t i = 0; i < nResponse; i++) {
            if (response[i] <= 0.0)
                continue;

            *chisquare += ZDiff[i] * ZDiff[i] / Z[i];
            nActiveChannel++;
        }
        *chisquare /= nActiveChannel;
    }
}
StatusCode AdUnfoldTool::RpcPointToAdLocal ( const DayaBay::CalibReadout readout,
Gaudi::XYZPoint &  rpcPoint 
) [private]

Definition at line 773 of file AdUnfoldTool.cc.

{
    Char_t *siteName = "";
    if (readout.detector().site() == Site::kDayaBay)
        siteName = "db";
    else
    if (readout.detector().site() == Site::kLingAo)
        siteName = "la";
    else
    if (readout.detector().site() == Site::kFar)
        siteName = "far";

    // Transform from RPC local to global coordinates
    const Char_t *rpcDEName = Form("/dd/Structure/DayaBay/%s-rock/%s-rpc", siteName, siteName);
    SmartDataPtr<IDetectorElement> rpcDE(m_detDataSvc, rpcDEName);
    if (!rpcDE) return StatusCode::FAILURE;
    Gaudi::XYZPoint rpcGlobalPoint = rpcDE->geometry()->toGlobal(rpcPoint);

    // Transform from global to AD local coordinates
    const Char_t *adDEName = Form("/dd/Structure/DayaBay/%s-rock/%s-ows/%s-curtain/%s-iws/%s-ade%d/%s-sst%d/%s-oil%d",
                                  siteName, siteName, siteName, siteName,
                                  siteName, readout.detector().detectorId(),
                                  siteName, readout.detector().detectorId(),
                                  siteName, readout.detector().detectorId());
    SmartDataPtr<IDetectorElement> adDE(m_detDataSvc, adDEName);
    if (!adDE) return StatusCode::FAILURE;
    rpcPoint = adDE->geometry()->toLocal(rpcGlobalPoint);

    return StatusCode::SUCCESS;
}
void AdUnfoldTool::WeightedLeastSquaresRegression ( Int_t  nPoint,
const std::vector< Double_t > &  x,
const std::vector< Double_t > &  y,
const std::vector< Double_t > &  weight,
Double_t &  slope,
Double_t &  intercept,
Double_t &  slopeError,
Double_t &  interceptError 
) [private]

Definition at line 804 of file AdUnfoldTool.cc.

{
    if (nPoint < 2) return;

    Double_t sumW = 0.0;
    Double_t sumWX = 0.0, sumWY = 0.0;
    Double_t sumWXX = 0.0, sumWXY = 0.0;

    for (Int_t i = 0; i < nPoint; i++) {
        Double_t W = weight[i];
        Double_t WX = W * x[i];
        Double_t WY = W * y[i];

        sumW += W;
        sumWX += WX;
        sumWY += WY;
        sumWXX += WX * x[i];
        sumWXY += WX * y[i];
    }

    Double_t delta = sumW*sumWXX - sumWX*sumWX;
    slope = (sumW*sumWXY - sumWX*sumWY) / delta;
    intercept = (sumWY - slope*sumWX) / sumW;
    slopeError = sqrt(sumW / delta);
    interceptError = sqrt(sumWXX / delta);
}
void AdUnfoldTool::GoodnessOfFit ( Int_t  nPoint,
const std::vector< Double_t > &  x,
const std::vector< Double_t > &  y,
const std::vector< Double_t > &  z,
const std::vector< Double_t > &  weight,
Double_t  slopeX,
Double_t  interceptX,
Double_t  slopeY,
Double_t  interceptY,
Double_t &  chisquare,
Double_t &  rsquare 
) [private]

Definition at line 836 of file AdUnfoldTool.cc.

{
    if (nPoint < 2) return;

    Double_t sumW = 0.0;
    Double_t sumWX = 0.0, sumWY = 0.0;

    for (Int_t i = 0; i < nPoint; i++) {
        sumW += weight[i];
        sumWX += weight[i] * x[i];
        sumWY += weight[i] * y[i];
    }

    Double_t meanX = sumWX / sumW;
    Double_t meanY = sumWY / sumW;
    Double_t totsquare = 0.0;
    chisquare = 0.0;

    for (Int_t i = 0; i < nPoint; i++) {
        Double_t fittedX = slopeX * z[i] + interceptX;
        Double_t fittedY = slopeY * z[i] + interceptY;
        Double_t resFitX = x[i] - fittedX;
        Double_t resFitY = y[i] - fittedY;
        Double_t resMeanX = x[i] - meanX;
        Double_t resMeanY = y[i] - meanY;

        chisquare += weight[i] * (resFitX*resFitX + resFitY*resFitY);
        totsquare += weight[i] * (resMeanX*resMeanX + resMeanY*resMeanY);
    }

    rsquare = 1.0 - (chisquare / totsquare);
}
void AdUnfoldTool::LinearRegression ( Int_t  nPoint,
const std::vector< TVectorD > &  pointsAd,
const std::vector< TVectorD > &  pointsRpc,
Double_t &  slopeX,
Double_t &  interceptX,
Double_t &  slopeY,
Double_t &  interceptY,
Double_t &  slopeErrorX,
Double_t &  interceptErrorX,
Double_t &  slopeErrorY,
Double_t &  interceptErrorY,
Double_t &  chisquare,
Double_t &  rsquare 
) [private]

Definition at line 876 of file AdUnfoldTool.cc.

{
    std::vector<Double_t> arrayX(nPoint, 0.0);
    std::vector<Double_t> arrayY(nPoint, 0.0);
    std::vector<Double_t> arrayZ(nPoint, 0.0);
    std::vector<Double_t> arrayW(nPoint, 0.0);

    for (Int_t i = 0; i < nPoint; i++) {
        arrayX[i] = pointsAd[i][0];
        arrayY[i] = pointsAd[i][1];
        arrayZ[i] = pointsAd[i][2];
        arrayW[i] = pointsAd[i][3];
    }
    for (Int_t i = 0; i < (Int_t)pointsRpc.size(); i++) {
        arrayX[nPoint-i-1] = pointsRpc[i][0];
        arrayY[nPoint-i-1] = pointsRpc[i][1];
        arrayZ[nPoint-i-1] = pointsRpc[i][2];
        arrayW[nPoint-i-1] = pointsRpc[i][3];
    }

    WeightedLeastSquaresRegression(nPoint, arrayZ, arrayX, arrayW, slopeX, interceptX, slopeErrorX, interceptErrorX);
    WeightedLeastSquaresRegression(nPoint, arrayZ, arrayY, arrayW, slopeY, interceptY, slopeErrorY, interceptErrorY);
    GoodnessOfFit(nPoint, arrayX, arrayY, arrayZ, arrayW, slopeX, interceptX, slopeY, interceptY, chisquare, rsquare);
}
void AdUnfoldTool::DirectionBiasCorrection ( Double_t  rsquare,
Double_t &  dx,
Double_t &  dy,
Double_t &  dz,
Double_t &  dxErr,
Double_t &  dyErr,
Double_t &  dzErr 
) [private]

Definition at line 908 of file AdUnfoldTool.cc.

{
}
Double_t AdUnfoldTool::TrackLengthInCylinder ( Double_t  targetH,
Double_t  targetD,
Double_t  vx,
Double_t  vy,
Double_t  vz,
Double_t  dx,
Double_t  dy,
Double_t  dz 
) [private]

Definition at line 914 of file AdUnfoldTool.cc.

{
    Double_t slopeX = dx / dz;
    Double_t slopeY = dy / dz;
    Double_t interceptX = vx - slopeX * vz;
    Double_t interceptY = vy - slopeY * vz;

    Double_t zBtm = -targetH / 2.0;
    Double_t xBtm = slopeX * zBtm + interceptX;
    Double_t yBtm = slopeY * zBtm + interceptY;
    Double_t zTop = targetH / 2.0;
    Double_t xTop = slopeX * zTop + interceptX;
    Double_t yTop = slopeY * zTop + interceptY;
    Double_t dX = xTop - xBtm;
    Double_t dY = yTop - yBtm;
    Double_t dZ = zTop - zBtm;
    Double_t radius = targetD / 2.0;

    Double_t xBtm2 = xBtm * xBtm;
    Double_t yBtm2 = yBtm * yBtm;
    Double_t xTop2 = xTop * xTop;
    Double_t yTop2 = yTop * yTop;
    Double_t dX2 = dX * dX;
    Double_t dY2 = dY * dY;
    Double_t dZ2 = dZ * dZ;
    Double_t radius2 = radius * radius;

    Double_t a0 = xBtm2 + yBtm2 - radius2;
    Double_t a1 = 2.0*(xBtm*dX + yBtm*dY);
    Double_t a2 = dX2 + dY2;
    Double_t discriminant = a1*a1 - 4.0*a0*a2;

    Double_t trackLength = 0.0;

    if (discriminant == 0.0) {
        if ((xBtm2 + yBtm2) <= radius2)
            trackLength = targetH;
    } else if (discriminant > 0.0) {
        Double_t discriminantRoot = TMath::Sqrt(discriminant);
        Double_t trackLength2DTotal = TMath::Sqrt(dX2 + dY2);
        Double_t trackLength2D = trackLength2DTotal;

        if ((xBtm2 + yBtm2) > radius2) {
            Double_t z = (-a1 - discriminantRoot) / (2.0 * a2);
            Double_t x = dX * z + xBtm;
            Double_t y = dY * z + yBtm;
            Double_t dXBtm = x - xBtm;
            Double_t dYBtm = y - yBtm;

            trackLength2D -= TMath::Sqrt(dXBtm*dXBtm + dYBtm*dYBtm);
        }
        if ((xTop2 + yTop2) > radius2) {
            Double_t z = (-a1 + discriminantRoot) / (2.0 * a2);
            Double_t x = dX * z + xBtm;
            Double_t y = dY * z + yBtm;
            Double_t dXTop = x - xTop;
            Double_t dYTop = y - yTop;

            trackLength2D -= TMath::Sqrt(dXTop*dXTop + dYTop*dYTop);
        }

        if (trackLength2D <= 0.0)
            trackLength = 0.0;
        else
            trackLength = TMath::Sqrt(dX2 + dY2 + dZ2) * trackLength2D / trackLength2DTotal;
    }

    return trackLength;
}
void AdUnfoldTool::DiagnosticPlot ( const DayaBay::CalibReadout readout,
const Char_t *  name,
const Char_t *  title,
const std::vector< TVectorD > &  profile,
Int_t  nGroup = 0 
) [private]

Definition at line 986 of file AdUnfoldTool.cc.

{
    if (m_diagnosticMode > 0) {
        TH2F hDiagXY(Form("trig%u_%s_xy", readout.triggerNumber(), name),
                     title, 50, -2500.0, 2500.0, 50, -2500.0, 2500.0);
        TH2F hDiagXZ(Form("trig%u_%s_xz", readout.triggerNumber(), name),
                     title, 50, -2500.0, 2500.0, 50, -2500.0, 2500.0);
        TH2F hDiagYZ(Form("trig%u_%s_yz", readout.triggerNumber(), name),
                     title, 50, -2500.0, 2500.0, 50, -2500.0, 2500.0);

        if (nGroup == 0)
            nGroup = profile.size();

        for (Int_t i = 0; i < nGroup; i++) {
            Double_t x = profile[i][0];
            Double_t y = profile[i][1];
            Double_t z = profile[i][2];
            Double_t w = profile[i][3];

            hDiagXY.Fill(x, y, w);
            hDiagXZ.Fill(x, z, w);
            hDiagYZ.Fill(y, z, w);
        }

        const Char_t *path = gDirectory->GetPath();
        gDirectory->cd(m_diagnosticFile->GetPath());

        hDiagXY.Write();
        hDiagXZ.Write();
        hDiagYZ.Write();

        gDirectory->cd(path);
    }
}

Member Data Documentation

std::string AdUnfoldTool::m_cableSvcName [private]

Definition at line 116 of file AdUnfoldTool.h.

Definition at line 118 of file AdUnfoldTool.h.

std::string AdUnfoldTool::m_calibDataSvcName [private]

Definition at line 121 of file AdUnfoldTool.h.

Definition at line 123 of file AdUnfoldTool.h.

std::string AdUnfoldTool::m_recDataSvcName [private]

Definition at line 126 of file AdUnfoldTool.h.

Definition at line 128 of file AdUnfoldTool.h.

std::string AdUnfoldTool::m_detDataSvcName [private]

Definition at line 131 of file AdUnfoldTool.h.

IDataProviderSvc* AdUnfoldTool::m_detDataSvc [private]

Definition at line 133 of file AdUnfoldTool.h.

Definition at line 136 of file AdUnfoldTool.h.

std::string AdUnfoldTool::m_filenameLinearity [private]

Definition at line 138 of file AdUnfoldTool.h.

std::string AdUnfoldTool::m_filenameMatrix [private]

Definition at line 140 of file AdUnfoldTool.h.

Definition at line 142 of file AdUnfoldTool.h.

Definition at line 144 of file AdUnfoldTool.h.

Definition at line 146 of file AdUnfoldTool.h.

Definition at line 148 of file AdUnfoldTool.h.

Definition at line 150 of file AdUnfoldTool.h.

Definition at line 152 of file AdUnfoldTool.h.

Definition at line 154 of file AdUnfoldTool.h.

Float_t AdUnfoldTool::m_lsLightYield [private]

Definition at line 156 of file AdUnfoldTool.h.

Int_t AdUnfoldTool::m_randomSeed [private]

Definition at line 158 of file AdUnfoldTool.h.

Definition at line 160 of file AdUnfoldTool.h.

std::string AdUnfoldTool::m_rpcRecHeaderLocation [private]

Definition at line 163 of file AdUnfoldTool.h.

Definition at line 165 of file AdUnfoldTool.h.

Definition at line 169 of file AdUnfoldTool.h.

Int_t AdUnfoldTool::m_reconNGroup [private]

Definition at line 170 of file AdUnfoldTool.h.

std::vector<TVectorD> AdUnfoldTool::m_groupList [private]

Definition at line 171 of file AdUnfoldTool.h.

TMatrixD AdUnfoldTool::m_responseMatrix [private]

Definition at line 172 of file AdUnfoldTool.h.

TMatrixD AdUnfoldTool::m_distanceMap [private]

Definition at line 173 of file AdUnfoldTool.h.

Double_t AdUnfoldTool::m_profile0Factor [private]

Definition at line 174 of file AdUnfoldTool.h.

TRandom3 AdUnfoldTool::m_random [private]

Definition at line 175 of file AdUnfoldTool.h.

Double_t AdUnfoldTool::m_rpcTriggerTime [private]

Definition at line 177 of file AdUnfoldTool.h.

std::vector<const DayaBay::RecRpcCluster *> AdUnfoldTool::m_rpcClusters [private]

Definition at line 178 of file AdUnfoldTool.h.

std::map<Site::Site_t, Gaudi::XYZPoint> AdUnfoldTool::m_rpcRecOffset [private]

Definition at line 179 of file AdUnfoldTool.h.

Definition at line 227 of file AdUnfoldTool.h.

clock_t AdUnfoldTool::m_clockElapsed [private]

Definition at line 235 of file AdUnfoldTool.h.

Float_t AdUnfoldTool::m_timeElapsed [private]

Definition at line 236 of file AdUnfoldTool.h.

Int_t AdUnfoldTool::m_nEventTotal [private]

Definition at line 237 of file AdUnfoldTool.h.

Definition at line 237 of file AdUnfoldTool.h.

Definition at line 237 of file AdUnfoldTool.h.


The documentation for this class was generated from the following files:
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

Generated on Fri May 16 2014 10:12:00 for AdUnfold by doxygen 1.7.4