ROOT logo
//*-- Author   : 08/06/2006 D. Gonzalez-Diaz
//*-- Modified : 12/06/2006 D. Gonzalez-Diaz
//*-- Modified : 13/12/2009 D. Gonzalez-Diaz
//*-- Modified : 24/11/2010 P. Cabanelas DigiPar container moved to
//*-- Modified :            condition style.
//*-- Modified : 22/06/2012 A.Mangiarotti General code cleanup.
//*-- Modified :            Geometry parameters used in several places
//*-- Modified :            are now stored as local variables (see D,
//*-- Modified :            geaXLoc). Reading of the digitiser
//*-- Modified :            parameters, which are constant, moved out
//*-- Modified :            of the hit processing loop (see vprop,
//*-- Modified :            sigma_el, sigma_T, t_offset, Qmean, gap)!
//*-- Modified :            The inefficiency per gap for normally
//*-- Modified :            incident particles ineff_gap_n is
//*-- Modified :            calculated once for all outside the hit
//*-- Modified :            loop. Namespace TMath used consistently
//*-- Modified :            everywhere. The procedure has been
//*-- Modified :            simplified. First the ideal left and
//*-- Modified :            right times left->gtime and right->gtime
//*-- Modified :            are calculated and after the resolutions
//*-- Modified :            are added to obtain left->time and
//*-- Modified :            right->time.
//*-- Modified : 20/09/2012 A.Mangiarotti Special treatment of
//*-- Modified :            particles produced in the gap.
//*-- Modified : 20/11/2012 A.Mangiarotti modified to include the new
//*-- Modified :            model II with parametrised dependences on
//*-- Modified :            the beta of the particles. Efficiency and
//*-- Modified :            time of flight resolution employ a
//*-- Modified :            sigmoid function. The charge distribution
//*-- Modified :            is now a Landau with parameters depending
//*-- Modified :            on beta with second degree polynomials.
//*-- Modified :            An attempt to correct on average for the
//*-- Modified :            number of active gaps is included. The
//*-- Modified :            old digitizer is now available as model
//*-- Modified :            I. If the old parameter container is
//*-- Modified :            found, model I is used automatically.
//*-- Modified : 27/11/2012 A.Mangiarotti added new cell wise mode of
//*-- Modified :            operation controllable with a flag
//*-- Modified :            (fMode=1). If the new mode is selected,
//*-- Modified :            the gaps are first reorganised into
//*-- Modified :            cells before applying the response with
//*-- Modified :            model I or model II. Two new internal
//*-- Modified :            structs celltrack and celldat added to
//*-- Modified :            handle the reorganisation of the gaps
//*-- Modified :            into cells. If model II is used in cell
//*-- Modified :            wise mode, no further corrections are
//*-- Modified :            needed for the average number of active
//*-- Modified :            gaps.
//*-- Modified : 27/02/2012 A.Mangiarotti A small bug has been
//*-- Modified :            corrected: the information about the
//*-- Modified :            local track length normalised to the gap
//*-- Modified :            was not propagated from gaps to cells.
//*-- Modified :            The access to the HGeantRpc is done with
//*-- Modified :            the new optimised getHitDigi to avoid
//*-- Modified :            retrieving information that is not used.
//*-- Modified : 03/03/2013 A.Mangiarotti Two new (private) methods
//*-- Modified :            have been introduced to streamline the
//*-- Modified :            digitiser operation and prepare for the
//*-- Modified :            different options available with the new
//*-- Modified :            HGeantRpc structure.
//*-- Modified : 10/03/2013 A.Mangiarotti Digitizer adapted to the
//*-- Modified :            new HGeantRpc structure: all the old
//*-- Modified :            options remain available for the old
//*-- Modified :            HGeantRpc to have full backward
//*-- Modified :            compatibility. With the new HGeantRpc
//*-- Modified :            only the cell wise mode is available.
//*-- Modified : 25/03/2013 J.Markert Code clean up. The particle
//*-- Modified :            mass is now consistently retrieved from
//*-- Modified :            HPhysicsConstants.
//*-- Modified : 09/07/2013 A.Mangiarotti counters nHGeantRpc and
//*-- Modified :            nDigitizedRpc introduced to flag the
//*-- Modified :            events with no generated hits and no
//*-- Modified :            digitised hits, respectively. This
//*-- Modified :            allows to avoid checking all
//*-- Modified :            cellobjects when nHGeantRpc=0 and all
//*-- Modified :            rpcobjects when nDigitizedRpc=0.
//*-- Modified :            Warning: when nHGeantRpc=0, the
//*-- Modified :            information on the HGeantRpc version
//*-- Modified :            in HGeantRpc_version is not available.
//*-- Modified : 04/12/2013 G.Kornakov   Added the embedding mode
/////////////////////////////////////////////////////////////////////
//  HRpcDigitizer digitizes HGeantRpc data, puts output values into
//  HRpcCalSim data category.
/////////////////////////////////////////////////////////////////////

#include "hrpcdigitizer.h"
#include "hades.h"
#include "hphysicsconstants.h"
#include "hruntimedb.h"
#include "hdebug.h"
#include "hspectrometer.h"
#include "hrpcdetector.h"
#include "hevent.h"
#include "hcategory.h"
#include "hiterator.h"
#include "hlocation.h"
#include "rpcdef.h"
#include "hgeantkine.h"
#include "hrpccalsim.h"
#include "hrpccal.h"
#include "hrpcdigipar.h"
#include "hrpcgeomcellpar.h"

#include "TRandom.h"

#include <iostream>
#include <iomanip>
using namespace std;

Float_t HRpcDigitizer::fCropDistance = 1.65;

HRpcDigitizer::HRpcDigitizer(void) {
    initVars();
}

HRpcDigitizer::HRpcDigitizer(const Text_t *name, const Text_t *title) :
HReconstructor(name,title) {
    initVars();
}

HRpcDigitizer::~HRpcDigitizer(void) {

    if(iterGeantRpc) delete iterGeantRpc;
    if(iterRpcCal)   delete iterRpcCal;
    clearObjects();
    cellobjects.clear();
    rpcobjects.clear();
}
void HRpcDigitizer::initVars(){

    fGeantRpcCat = 0;
    fCalCat      = 0;
    fKineCat     = 0;
    fGeomCellPar = 0;
    fDigiPar     = 0;
    fLoc.set(3,0,0,0);
    iterGeantRpc = 0;
    iterRpcCal   = 0;
}

Bool_t HRpcDigitizer::initParContainer() {
    fGeomCellPar=(HRpcGeomCellPar *)gHades->getRuntimeDb()->getContainer("RpcGeomCellPar");
    if(!fGeomCellPar){
        Error("HRpcDigitizer::init()","No RpcGeomCellPar Parameters");
        return kFALSE;
    }
    fDigiPar    =(HRpcDigiPar *)    gHades->getRuntimeDb()->getContainer("RpcDigiPar");
    if(!fDigiPar){
        Error("HRpcDigitizer::init()","No RpcDigiPar Parameters");
        return kFALSE;
    }
    return kTRUE;
}

Bool_t HRpcDigitizer::init(void) {

    HRpcDetector* rpc = (HRpcDetector*)(gHades->getSetup()->getDetector("Rpc"));


    if(!rpc){
        Error("HRpcDigitizer::init()","No Rpc Detector found");
        return kFALSE;
    }
    //---------------------------------------------------------------
    // Working arrays
    maxCol  = rpc->getMaxColumns();
    maxCell = rpc->getMaxCells();
    rpcobjects.resize(6*maxCol*maxCell, 0 );   // Size is constant over run time
    cellobjects.resize(6*maxCol*maxCell, 0 );  // Size is constant over run time
    //---------------------------------------------------------------

    //---------------------------------------------------------------
    // Parameters
    if(!initParContainer()) return kFALSE;
    //---------------------------------------------------------------

    //---------------------------------------------------------------
    // Data
    fKineCat = gHades->getCurrentEvent()->getCategory(catGeantKine);
    if(!fKineCat) {
        Error("HRpcDigitizer::init()","HGeant kine input missing");
        return kFALSE;
    }

    fGeantRpcCat = gHades->getCurrentEvent()->getCategory(catRpcGeantRaw);
    if(!fGeantRpcCat) {
        Error("HRpcDigitizer::init()","HGeant RPC input missing");
        return kFALSE;
    }

    // Build the Calibration category

    //Adding the embedding mode!
    if(gHades->getEmbeddingMode()>0) {
	//Getting the temporary category for calibrated rpc hits.
	fCalCat = gHades->getCurrentEvent()->getCategory(catRpcCalTmp);
        if(!fCalCat) {
	    fCalCat=rpc->buildMatrixCategory("HRpcCalSim",0.5);
	    gHades->getCurrentEvent()->addCategory(catRpcCalTmp,fCalCat,"Rpc");
	}
    } else {
	fCalCat = gHades->getCurrentEvent()->getCategory(catRpcCal);
	if(!fCalCat) {
	    fCalCat=rpc->buildMatrixCategory("HRpcCalSim",0.5);
	    gHades->getCurrentEvent()->addCategory(catRpcCal,fCalCat,"Rpc");
	}
    }

    iterGeantRpc = (HIterator *)fGeantRpcCat->MakeIterator("native");
    iterRpcCal   = (HIterator *)fCalCat     ->MakeIterator("native");
    //---------------------------------------------------------------

    return kTRUE;
}

Int_t HRpcDigitizer::execute(void) {

    HGeantRpc*  geantrpc = 0;
    HRpcCalSim* cal      = 0;

    Float_t mass;
    Int_t   RefL=-1,trackNumber,gpid,mode,ngap,HGeantRpc_version=-1;
    Int_t   nHGeantRpc=0,nDigitizedRpc=0;

    // Load the relevant parameters

    vprop       = fDigiPar->getVprop();                                  // [mm/ns]
    sigma_el    = (fDigiPar->getSigmaX()) / vprop;                       // [ns]
    sigma0_T    = (fDigiPar->getSigmaT())  / 1000.;                      // [ns]
    sigma1_T    = (fDigiPar->getSigmaT1()) / 1000.;                      // [ns]
    sigma2_T    = (fDigiPar->getSigmaT2());                              // pure number
    sigma3_T    = (fDigiPar->getSigmaT3());                              // pure number
    t_offset    = (fDigiPar->getToff()) / 1000.;                         // [ns]
    Qmean0      = (fDigiPar->getQmean());                                // [pC]
    Qmean1      = (fDigiPar->getQmean1());                               // [pC]
    Qmean2      = (fDigiPar->getQmean2());                               // [pC]
    Qwid0       = (fDigiPar->getQwid());                                 // [pC]
    Qwid1       = (fDigiPar->getQwid1());                                // [pC]
    Qwid2       = (fDigiPar->getQwid2());                                // [pC]
    Eff0        = (fDigiPar->getEff());                                  // pure number
    Eff1        = (fDigiPar->getEff1());                                 // pure number
    Eff2        = (fDigiPar->getEff2());                                 // pure number
    Eff3        = (fDigiPar->getEff3());                                 // pure number
    Eff4        = (fDigiPar->getEff4());                                 // pure number
    Eff5        = (fDigiPar->getEff5());                                 // pure number
    gap         = fDigiPar->getGap();                                    // [mm]
    mode        = fDigiPar->getMode();                                   // mode flag
    //
    if((sigma1_T<=0.)||(sigma2_T<=0.)||(sigma3_T<=0.)) {
      // Digitizing model I.
      sigma_el *= TMath::Sqrt2();
    }
    //
    //if((mode==0)&&(HGeantRpc_version==5)) {
    //  Error("HRpcDigitizer::init()","HGeantRpc version 5 does not allow gap mode");
    //  return kFALSE;
    //}


    //---------------------------------------------------------------
    // Loop over the HGeantrpc objects, i.e, over the gaps/cells
    // and fill temporary working objects
    clearObjects();
    iterGeantRpc->Reset();
    nHGeantRpc=0;
    nDigitizedRpc=0;
    while ((geantrpc=(HGeantRpc *)iterGeantRpc->Next()) != 0) {
        geantrpc->setVersion(5);
        // Skip hit in virtual volume EBOX.
        if(geantrpc->getDetectorID() < 0) continue;
        // Count number of HGeantRpc objects excluding hits
	// in virtual volume EBOX.

        // Crop 1.5 mm of the closest to the cell edges along the X coordinate
        if(getDistanceToXedge(geantrpc)<fCropDistance) continue;

        nHGeantRpc++;


        // Initialise HGeantRpc version and efficiency caluclation.
        if(HGeantRpc_version==-1) {
          HGeantRpc_version = geantrpc->getVersion();
          if(HGeantRpc_version<=4) {
            // Initialise the inefficency of a gap.
            calc_eff_hit(-1);
          } else {
            // Initialise the inefficency of a cell.
            calc_eff_hit(-2);
          }
        }

        // Retrive hit.
        // Units are [mm], [ns], [MeV/c], [mm] in module ref system.
        if(HGeantRpc_version<=4) {
          // Get simulation output of a gap.
          geantrpc->getHitDigi(geaX, geaTof, geaMom, geaLocLen);
        } else {
          // Get simulation output of a cell.
          geantrpc->getCellAverageDigi(gap, geaX, geaTof, geaMom, geaLocLen);
        }
        // If the gap enetering was missed in Geant, assume the gap as local track length.
        if(geaLocLen<0.) {
          geaLocLen=gap;
          geaLocLenNorm=1.;
        } else {
          geaLocLenNorm=geaLocLen/gap;
        }

        // Determine the beta of the particle.
        trackNumber = geantrpc->getTrack();
        HGeantKine* kine = (HGeantKine*)fKineCat->getObject(trackNumber-1);
        if(!kine) {
          Warning("HRpcDigitizer::execute()",
                  "missing kine entry for track %i, assuming beta=0",trackNumber);
          beta=0.;
        } else {
          gpid =  kine->getID();
          // From the Geant particle type find the mass (only charged
          // particles need to be considered).
	  mass = HPhysicsConstants::mass(gpid);
	  if(mass <= 0 ){
	      if(mass < 0 ) Warning("HRpcDigitizer::execute()",
				    "unknown particle id %i, assuming proton mass",gpid);
	      mass = HPhysicsConstants::mass(14); // unknown + gamma
	  }

          beta=mass/geaMom;
          beta=1./TMath::Sqrt(1.+beta*beta);
        }

        fLoc[0] = geantrpc->getSector();
        fLoc[1] = geantrpc->getColumn();
        fLoc[2] = geantrpc->getCell();

        // Apply efficiency.
        if(HGeantRpc_version<=4) {
          // Calculate the efficiency of a gap.
          calc_eff_hit(1);
        } else {
          // Calculate the efficiency of a cell.
          calc_eff_hit(2);
        }
        // This may depend a bit on the digitization algorithm.
	efhits hite;
        Float_t axe = -9999;
        Float_t aye = -9999;
        Float_t aze = -9999;
        Float_t ate = -9999;
        geantrpc->getCellAverage(axe, aye, aze, ate);
	Float_t rnd = gRandom->Uniform(1);
        hite.set(fLoc[0], fLoc[1], fLoc[2], axe, aye, ate, rnd<=eff_hit);
	//if(gRandom->Uniform(1) > eff_hit) {
	Int_t efprev = -1;
	for(UInt_t e=0;e<effi_vec.size();e++) {
	    if(fLoc[0]==effi_vec[e].sector &&
	       fLoc[1]==effi_vec[e].module &&
	       fLoc[2]==effi_vec[e].cell   &&
               fabs(axe-effi_vec[e].x)<2.  &&
               fabs(aye-effi_vec[e].y)<2.  &&
	       fabs(ate-effi_vec[e].time)<2.)
                efprev = effi_vec[e].effi;
	}
	if(efprev==0) {
	    continue;
	}
	if(efprev==-1 && rnd > eff_hit) {
	    effi_vec.push_back(hite);
	    continue;
	}
        if(efprev==-1 && rnd <= eff_hit) {
	    effi_vec.push_back(hite);
	}

        if((mode==0)||(HGeantRpc_version==5)) {
        /////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////
        //////////// BEGIN GAP WISE OPEREATION (MODE=0) /////////////
	//////////// WITH OLD HGeantRpc before Jan 2013 /////////////
        //////////// BEGIN CELL WISE OPEREATION         /////////////
	//////////// WITH NEW HGeantRpc after Jan 2013  /////////////
        /////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////


          //---------------------------------------------------------
          // Collect data
          // objects are stored linear
          Int_t ind = fLoc[0] * maxCol * maxCell + fLoc[1] * maxCell + fLoc[2];

          if(rpcobjects[ind] == 0) {
            // First time we have to create the object
            rpcobjects[ind] = new rpcdat;
            //rpcobjects[ind]->linIndex= ind;
            rpcobjects[ind]->sec  = fLoc[0];
            rpcobjects[ind]->col  = fLoc[1];
            rpcobjects[ind]->cell = fLoc[2];
          }
          rpcdat* dat = rpcobjects[ind];
          //---------------------------------------------------------
          // Create new objects for left/right of the gap
          // and add them to the list of gaps for this cell
          gaptrack* left  = new gaptrack;
          gaptrack* right = new gaptrack;

          left ->reset();
          right->reset();

          dat->left .push_back(left);
          dat->right.push_back(right);
          //---------------------------------------------------------

          left ->refDgtr   = fGeantRpcCat->getIndex(geantrpc);
          left ->trackDgtr = ((HGeantRpc*)fGeantRpcCat->getObject(left->refDgtr))->getTrack();

          // Right is the same as left
          right->refDgtr   = left->refDgtr;
          right->trackDgtr = left->trackDgtr;

          RefL  = findMother(left->refDgtr); // Right is the same as left , do it only once

          if(RefL < 0){ // Mother not found. Very seldom. Keep info of daughter.
            left ->ref     = left ->refDgtr;
            left ->track   = left ->trackDgtr;
            left ->isAtBox = kFALSE;
            right->ref     = left ->refDgtr;
            right->track   = left ->trackDgtr;
            right->isAtBox = kFALSE;
            Warning("HRpcDigitizer::execute()",
                    "mother of track not found in RPC box! will use RefLDgtr=%i, TrackLDgtr=%i",
                    left->refDgtr,left->trackDgtr);
          } else {      // Mother found
            left ->track   = ((HGeantRpc*)fGeantRpcCat->getObject(RefL))->getTrack();
            left ->ref     = RefL;
            left ->isAtBox = kTRUE;

            right->track   = left->track;
            right->ref     = left->ref;
            right->isAtBox = kTRUE;
          }

          // Cell length in mm
          D = fGeomCellPar->getLength(fLoc[1],fLoc[2]);
          if(HGeantRpc_version<=4) {
            // Apply the response of a gap.
            digitize_one_hit(left,right,0);
          } else {
            // Apply the response of a cell.
            digitize_one_hit(left,right,1);
          }
          nDigitizedRpc++;

          //---------------------------------------------------------

        /////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////
        //////////// END GAP WISE OPEREATION (MODE=0)   /////////////
	//////////// WITH OLD HGeantRpc before Jan 2013 /////////////
        //////////// END CELL WISE OPEREATION           /////////////
	//////////// WITH NEW HGeantRpc after Jan 2013  /////////////
        /////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////


        } else {


        /////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////
        //////////// BEGIN CELL WISE OPEREATION (MODE=1) ////////////
	//////////// WITH OLD HGeantRpc before Jan  2013 ////////////
        /////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////
          //---------------------------------------------------------
          // Collect data
          // objects are stored linear
          Int_t ind = fLoc[0] * maxCol * maxCell + fLoc[1] * maxCell + fLoc[2];

          if(cellobjects[ind] == 0) {
            // First time we have to create the object
            cellobjects[ind] = new celldat;
            //rpcobjects[ind]->linIndex= ind;
            cellobjects[ind]->sec  = fLoc[0];
            cellobjects[ind]->col  = fLoc[1];
            cellobjects[ind]->cell = fLoc[2];
          }
          celldat* cdat = cellobjects[ind];
          //---------------------------------------------------------
          // Create new objects for the track crossing the cell
          // and add them to the list of tracks for this cell
          celltrack* celltr;
          // CASE I: no tacks in this cell yet
          if(cdat->celltr.size()==0) {
            celltr = new celltrack;
            celltr->reset();
            cdat->celltr.push_back(celltr);
          // CASE II: this cell has already tracks associated
          // with it
          } else {
            // Look if current track is already present in the list
            for(UInt_t i=0;i<cdat->celltr.size();i++){
              celltr = cdat->celltr[i];
              // CASE II a: the current track is already associated,
              // so select it
              if(celltr->track == trackNumber) break;
            }
            // CASE II b: the current track is not associated,
            // so add it
            if(celltr->track != trackNumber) {
              celltr = new celltrack;
              celltr->reset();
              cdat->celltr.push_back(celltr);
            }
          }
          //---------------------------------------------------------

          ngap = geantrpc->getGap();
          // The condition on the time takes care of possible multiple
          // re-entries of the same track.
          if(celltr->gaptime[ngap]==0.) {
            celltr->gaptime[ngap] = geaTof;
            celltr->gappos[ngap]  = geaX;
            celltr->gapltln[ngap] = geaLocLenNorm;
            celltr->gapbeta[ngap] = beta;
            celltr->track         = trackNumber;
            celltr->geantrpcIndex = fGeantRpcCat->getIndex(geantrpc);
          } else if(celltr->gaptime[ngap]<geaTof) {
            celltr->gaptime[ngap] = geaTof;
            celltr->gappos[ngap]  = geaX;
            celltr->gapltln[ngap] = geaLocLenNorm;
            celltr->gapbeta[ngap] = beta;
            celltr->track         = trackNumber;
            celltr->geantrpcIndex = fGeantRpcCat->getIndex(geantrpc);
            Warning("HRpcDigitizer::execute()",
                    "reentry of track=%i in Sector=%i Module=%i Cell=%i",
                    trackNumber,fLoc[0],fLoc[1],fLoc[2]);
          }

        /////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////
        //////////// END CELL WISE OPEREATION (MODE=1)  /////////////
	//////////// WITH OLD HGeantRpc before Jan 2013 /////////////
        /////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////

        }

        // End of algorithm

    } // End of HGeantRpc loop


    //---------------------------------------------------------------
    // If in cell mode and version of HGeantRpc is after Jan 2013,
    // process cells
    if((mode>0)&&(HGeantRpc_version<=4)&&(nHGeantRpc>0)) {
      for(UInt_t i = 0; i < cellobjects.size(); i ++) {
        celldat* cdat = cellobjects[i];
        if(cdat){
          fLoc[0] = cdat->sec;
          fLoc[1] = cdat->col;
          fLoc[2] = cdat->cell;

          // Change to cell coordinate system (with origin at the cell center)
          // Note that fGeomCellPar->getX(column,cell) corresponds to the left-down corner
          // Cell length in mm
          D = fGeomCellPar->getLength(fLoc[1],fLoc[2]);

          // Objects are stored linear
          Int_t ind = fLoc[0] * maxCol * maxCell + fLoc[1] * maxCell + fLoc[2];

          if(rpcobjects[ind] == 0) {
            // First time we have to create the object
            rpcobjects[ind] = new rpcdat;
            //rpcobjects[ind]->linIndex= ind;
            rpcobjects[ind]->sec  = fLoc[0];
            rpcobjects[ind]->col  = fLoc[1];
            rpcobjects[ind]->cell = fLoc[2];
          }
          rpcdat* dat = rpcobjects[ind];


          for(UInt_t j = 0; j < cdat->celltr.size(); j ++) {
            celltrack* celltr = cdat->celltr[j];
            celltr->calcMeans();

            //-------------------------------------------------------
            // Create new objects for left/right of the gap
            // and add them to the list of gaps for this cell
            gaptrack* left  = new gaptrack;
            gaptrack* right = new gaptrack;

            left ->reset();
            right->reset();

            dat->left .push_back(left);
            dat->right.push_back(right);
            //-------------------------------------------------------

            left ->refDgtr   = celltr->geantrpcIndex;
            left ->trackDgtr = ((HGeantRpc*)fGeantRpcCat->getObject(left->refDgtr))->getTrack();

            // Right is the same as left
            right->refDgtr   = left->refDgtr;
            right->trackDgtr = left->trackDgtr;

            RefL  = findMother(left->refDgtr); // Right is the same as left , do it only once

            if(RefL < 0){ // Mother not found. Very seldom. Keep info of daughter.
              left ->ref     = left ->refDgtr;
              left ->track   = left ->trackDgtr;
              left ->isAtBox = kFALSE;
              right->ref     = left ->refDgtr;
              right->track   = left ->trackDgtr;
              right->isAtBox = kFALSE;
              Warning("HRpcDigitizer::execute()",
                      "mother of track not found in RPC box! will use RefLDgtr=%i, TrackLDgtr=%i",
                      left->refDgtr,left->trackDgtr);
            } else {      // Mother found
              left ->track   = ((HGeantRpc*)fGeantRpcCat->getObject(RefL))->getTrack();
              left ->ref     = RefL;
              left ->isAtBox = kTRUE;

              right->track   = left->track;
              right->ref     = left->ref;
              right->isAtBox = kTRUE;
            }

            // Geant Position
            geaX          = celltr->pos;
            // Geant Time
            geaTof        = celltr->time;
            // Geant local track length normalised to the gap
            geaLocLenNorm = celltr->ltln;
            // Geant Beta
            beta          = celltr->beta;
            // Apply response of a cell
            digitize_one_hit(left,right,1);
            nDigitizedRpc++;


            //-------------------------------------------------------

          }  // End of celltrack loop

        }

      }  // End of cellobjects loop
    }


    //---------------------------------------------------------------
    // Fill output
    if(nDigitizedRpc>0) {

      Int_t  Track    [10];
      Int_t  TrackDgtr[10];
      Bool_t isAtBox  [10];
      vector <Int_t> tracklist;
      tracklist.reserve(20); // Minimum size

      for(UInt_t i = 0; i < rpcobjects.size(); i ++) {
        rpcdat* dat = rpcobjects[i];
        if(dat){
            fLoc[0] = dat->sec;
            fLoc[1] = dat->col;
            fLoc[2] = dat->cell;

            //-------------------------------------------------------
	    // Test if cell in use. Needed in embedding mode:
	    //THIS OPTION IS NO MORE EXISTING: its used the tmp cat in the embedding mode
            // Neither in embedding mode nor in the standard this part should not be used!
            cal = (HRpcCalSim*) fCalCat->getObject(fLoc);
            if(cal) {
                // Add track from real data for sorting procedure
                gaptrack* left  = new gaptrack;
                gaptrack* right = new gaptrack;

                left ->reset();
                right->reset();

                dat->left .push_back(left);
                dat->right.push_back(right);

                left ->time      = cal->getLeftTime();
                left ->gtime     = cal->getLeftTime();
                left ->charge    = cal->getLeftCharge();
                left ->track     = gHades->getEmbeddingRealTrackId();
                left ->trackDgtr = gHades->getEmbeddingRealTrackId();
                left ->isAtBox   = kTRUE;
                right->time      = cal->getRightTime();
                right->gtime     = cal->getRightTime();
                right->charge    = cal->getRightCharge();
                right->track     = gHades->getEmbeddingRealTrackId();
                right->trackDgtr = gHades->getEmbeddingRealTrackId();
                right->isAtBox   = kTRUE;
            } else {
                cal = (HRpcCalSim*) fCalCat->getSlot(fLoc);
                if(!cal) Error("execute()","Error: could not allocate a new slot in HRpcCalSim!");
                cal = new(cal) HRpcCalSim;
                cal->setAddress(fLoc[0], fLoc[1], fLoc[2]);
            }
            //-------------------------------------------------------
            // Sort by GEANT time and select the fastest hit
            dat->sortTime(kTRUE);  // Right
            dat->sortTime(kFALSE); // Left
            if(((mode==0)&&((sigma1_T<=0.)||(sigma2_T<=0.)||(sigma3_T<=0.)))
               ||(mode>0)||(HGeantRpc_version==5)) {
              // Digitizing model I and II (except gap-wise)
              // Take the fastest in the left and in the right.
              cal->setRightTime(dat->getSmallestTof(kTRUE )); // Right
              cal->setLeftTime (dat->getSmallestTof(kFALSE)); // Left
            } else {
              // Digitizing model II gap-wise.
              // Take the average in the left and in the right.
              cal->setRightTime(dat->getMeanTof(kTRUE ));     // Right
              cal->setLeftTime (dat->getMeanTof(kFALSE));     // Left
            }
            cal->setRightCharge(dat->getSumCharge(kTRUE ));   // Right
            cal->setLeftCharge (dat->getSumCharge(kFALSE));   // Left

            cal->setRefR    (dat->right[0]->ref);
            cal->setRefRDgtr(dat->right[0]->refDgtr);
            cal->setRefL    (dat->left [0]->ref);
            cal->setRefLDgtr(dat->left [0]->refDgtr);
            //-------------------------------------------------------


            //-------------------------------------------------------
            // Fill list of tracks
            // and remove doubles

            //-------------------------------------------------------
            // Right side
            tracklist.clear();
            Int_t ct = 0;

            for(UInt_t j = 0; j < 10; j ++) {
                Track[j] = TrackDgtr[j] = -999;
                isAtBox[j] = kFALSE;
            }

            for(UInt_t j = 0; j < dat->right.size() && ct < 10; j ++ ){
                Int_t tr = dat->right[j]->track;
                if(find(tracklist.begin(),tracklist.end(),tr ) == tracklist.end()){
                    // Track was not stored before
                    Track    [ct] = tr;
                    TrackDgtr[ct] = dat->right[j]->trackDgtr;
                    isAtBox  [ct] = dat->right[j]->isAtBox;
                    // Remember used track
                    tracklist.push_back(tr);
                    ct ++;
                }
            }

            cal->setTrackRArray    (Track);
            cal->setTrackRDgtrArray(TrackDgtr);
            cal->setRisAtBoxArray  (isAtBox);
            cal->setNTracksR(ct);
            //-------------------------------------------------------

            //-------------------------------------------------------
            // Left side
            tracklist.clear();
            ct = 0;

            for(UInt_t j = 0; j < 10; j ++) {
                Track[j] = TrackDgtr[j] = -999;
                isAtBox[j] = kFALSE;
            }

            for(UInt_t j = 0; j < dat->left.size() && ct < 10 ; j ++ ){
                Int_t tr = dat->left[j]->track;
                if(find(tracklist.begin(),tracklist.end(),tr) == tracklist.end()){
                    // Track was not stored before
                    Track    [ct] = tr;
                    TrackDgtr[ct] = dat->left[j]->trackDgtr;
                    isAtBox  [ct] = dat->left[j]->isAtBox;
                    // Remember used track
                    tracklist.push_back(tr);
                    ct ++;
                }
            }

            cal->setTrackLArray    (Track);
            cal->setTrackLDgtrArray(TrackDgtr);
            cal->setLisAtBoxArray  (isAtBox);
            cal->setNTracksL(ct);
            //-------------------------------------------------------

            //-------------------------------------------------------
        }
      }
    }
    //---------------------------------------------------------------

    return 0;
}

void  HRpcDigitizer::clearObjects(){
    // Delete objects in working array and
    // set pointer to 0. vector is still
    // not cleared.
    effi_vec.clear();
    for(UInt_t i = 0; i < rpcobjects.size(); i ++){
        if(rpcobjects[i]){
            rpcobjects[i]->reset();
            delete rpcobjects[i];
            rpcobjects[i] = 0;
        }
    }
    for(UInt_t i = 0; i < cellobjects.size(); i ++){
        if(cellobjects[i]){
            cellobjects[i]->reset();
            delete cellobjects[i];
            cellobjects[i] = 0;
        }
    }
}

Int_t HRpcDigitizer::findMother(Int_t Ref_initial) {

  // Algorithm for finding mother. When not found, -1 is returned
  // in order to tag the track. It very rarely happens and is
  // always associated to neutral particles at the box.

  Int_t detectorID =  0, track_mother = -1, Ref_final = -1;

  HGeantRpc*  geantrpc = 0;
  HGeantKine* kine     = 0;

  track_mother = ((HGeantRpc*)fGeantRpcCat->getObject(Ref_initial))->getTrack();
  kine         = (HGeantKine*)fKineCat    ->getObject(track_mother - 1);

  while(kine && detectorID >= 0){

      if(track_mother == 0)  { //End of loop. Mother not found
          Ref_final = -999;
          break;
      }

      kine = (HGeantKine*)fKineCat->getObject(track_mother - 1);

      if(kine && kine->getNRpcHits() == 0) { //Mother has no hit in RPC cells
          track_mother = kine->getParentTrack();
          continue;
      }

      Ref_final    = kine->getFirstRpcHit(); //Look for the first hit (time-wise) of the track
      geantrpc     = (HGeantRpc*)fGeantRpcCat->getObject(Ref_final);
      detectorID   = geantrpc->getDetectorID();
      track_mother = kine->getParentTrack();

  }

  return Ref_final;
}

void HRpcDigitizer::calc_eff_hit(Int_t mode) {

  // Algorithm to calculate the inefficiency of a gap. The efficiency
  // in the digitizer parameters is ALWAYS per CELL.
  // If mode=-1 the efficiency/inefficiency per hit are initialised as per gap,
  // If mode=-2 the efficiency/inefficiency per hit are initialised as per cell,
  // If mode=1 the efficiency/inefficiency per hit are calculated as per gap,
  // If mode=2 the efficiency/inefficiency per hit are calculated as per cell.

  if(mode<0) {
  //
  // Initialisation call
  //
    if((Eff1==0.)||(Eff2<=0.)||(Eff3<=0.)) {
      // Digitizing model I.
      if(mode==-1) {
        // HIT == GAP
        ineff_hit_n = TMath::Sqrt(TMath::Sqrt(1. - fDigiPar->getEff()));
      } else {
        // HIT == CELL
        ineff_hit_n = 1. - fDigiPar->getEff();
      }
    } else {
      ineff_hit_n = 0.;
    }
  } else {
  //
  // Calculation call
  //
    if((Eff1==0.)||(Eff2<=0.)||(Eff3<=0.)) {
      // Digitizing model I.
      ineff_hit = TMath::Power(ineff_hit_n,geaLocLenNorm);    // correction for angle of incidence
    } else {
      // Digitizing model II.
      eff_hit = Eff0+Eff1/(1.+TMath::Exp(-Eff2*(beta-Eff3))) + TMath::Exp(Eff4*beta+Eff5);
      if(mode==1) {
        // HIT == GAP
        ineff_hit = TMath::Sqrt(TMath::Sqrt(1. - eff_hit));   // convert to inefficency of a gap
      } else {
        // HIT == CELL
        ineff_hit = 1. - eff_hit;
      }
      ineff_hit = TMath::Power(ineff_hit,(geaLocLenNorm));    // correction for angle of incidence
    }
    // Efficiency per gap
    eff_hit = 1. - ineff_hit;
  }
}

void HRpcDigitizer::digitize_one_hit(gaptrack* left,gaptrack* right,Int_t mode) {

  // Algorithm to calculate the response of a gap.
  // If mode=0 in MODEL II a corection for the average number of active
  // gaps is applyed.

  Float_t geaXLoc = 0.;
  Float_t beta2,corr_ngap,sigma_T,sigma_el_here,X_smearing,T_smearing;
  Float_t Qmean,Qwid,Qgap;

  // Change to cell coordinate system (with origin at the cell center)
  // Note that fGeomCellPar->getX(column,cell) corresponds to the left-down corner
  geaXLoc = fGeomCellPar->getX(fLoc[1],fLoc[2]) - geaX; // Position in cell frame

  // Calculate GEANT time left/right without smearing for sorting
  left->gtime  = geaTof + geaXLoc / vprop;              // Geant Time at left-end
  right->gtime = geaTof + (D-geaXLoc) / vprop;          // Geant Time at right-end


  // Common to left and right!. Intrinsic RPC fluctuations.
  if((sigma1_T<=0.)||(sigma2_T<=0.)||(sigma3_T<=0.)) {
    // Digitizing model I.
    // Common to left and right!. Intrinsic RPC fluctuations.
    T_smearing  = gRandom->Gaus(t_offset, sigma0_T);
    left ->time = left ->gtime + T_smearing + gRandom->Gaus(0.,sigma_el);
    right->time = right->gtime + T_smearing + gRandom->Gaus(0.,sigma_el);
  } else {
    // Digitizing model II.
    sigma_T = sigma0_T+sigma1_T/(1.+TMath::Exp(-sigma2_T*(beta-sigma3_T)));
    sigma_el_here=sigma_el;

    // Attempt to approximately correct for the number of active gaps.
    if(mode==0) {
      Float_t norm=0.;
      corr_ngap=0.;
      for(Int_t i = 1; i < 5; i ++) {
        Float_t w4i=TMath::Binomial(4,i)*TMath::Power(eff_hit,i)*TMath::Power(ineff_hit,4-i);
        norm += w4i;
        corr_ngap += w4i/TMath::Sqrt((Float_t)i);
      }
      // The correction factor for the sigma of the Gaussian is the
      // inverse of corr_ngap/norm, to have a multiplicative correction
      // it is calculated here once for all.
      corr_ngap = norm/corr_ngap;
      sigma_T       *= corr_ngap;
      sigma_el_here *= corr_ngap;
    }

    T_smearing = gRandom->Gaus(t_offset,sigma_T);
    // The position and time resolutions are decoupled.
    X_smearing = gRandom->Gaus(0.,sigma_el_here);
    //X_smearing = 0.;
    left ->time = left ->gtime + T_smearing + X_smearing;
    right->time = right->gtime + T_smearing - X_smearing;
  }

  // Generated charge.
  if(Qwid0<=0.) {
    // Digitizing model I.
    // Charge distribution assumed to be flat per gap. At present slewing
    // correction is not included. Also charges in left and in right are
    // *exactly* the same by definition. A smearing in charge to account
    // for the resolution of the Q2W method can be easily included.
    Qgap = (gRandom->Uniform(1)) * (2. * Qmean0) / 4. * geaLocLenNorm; // Correction for angle of incidence
  } else {
    // Digitizing model II.
    // Use Landau distribution with a mean and width parametrised with
    // second order polynomials in beta.
    beta2 = beta*beta;
    Qmean = Qmean0+Qmean1*beta+Qmean2*beta2;
    Qwid  = Qwid0 +Qwid1*beta +Qwid2*beta2;

    // Attempt to approximately correct for the number of active gaps.
    if(mode==0) {
      Float_t norm=0.;
      corr_ngap=0.;
      for(Int_t i = 1; i < 5; i ++) {
        Float_t w4i=TMath::Binomial(4,i)*TMath::Power(eff_hit,i)*TMath::Power(ineff_hit,4-i);
        norm += w4i;
        corr_ngap += w4i*TMath::Sqrt((Float_t)i);
      }
      // The correction factor for the sigma of the Gaussian is the
      // inverse of corr_ngap/norm, to have a multiplicative correction
      // it is calculated here once for all. Note that this is very
      // approximate for a Landau distribution.
      corr_ngap = norm/corr_ngap;
      // Per gap.
      Qmean /= (4.*eff_hit);
      // Per gap.
      Qwid  *= corr_ngap;
    }

    // Correction for angle of incidence.
    Qmean *= geaLocLenNorm;
    // Correction for angle of incidence.
    Qwid  *= geaLocLenNorm;
    Qgap   = gRandom->Landau(Qmean,Qwid);
  }
  left ->charge = Qgap;
  right->charge = Qgap;
}

Float_t HRpcDigitizer::getDistanceToXedge(HGeantRpc * gea) {
    if(!fGeomCellPar || gea->getDetectorID() < 0) {
	return -1.;
    }
    
    Int_t module = gea->getColumn();
    Int_t cell   = gea->getCell();
    if(module<0 || cell<0) {
	return -1.;
    }
    Float_t axHit   = 0.;
    Float_t ayHit   = 0.;
    Float_t azHit   = 0.;
    Float_t atofHit = 0.;
    gea->getCellAverage(axHit, ayHit, azHit, atofHit);
    // In case the cell number is not the first:
    Float_t xCorner  = fGeomCellPar->getX(module,cell);
    Float_t yCorner  = fGeomCellPar->getY(module,cell);
    Float_t length   = fGeomCellPar->getLength(module,cell);
    Float_t rxCorner  = xCorner  - length;

    Int_t trackNumber = gea->getTrack();
    HGeantKine* kine = (HGeantKine*)fKineCat->getObject(trackNumber-1);
    if(!kine) return 0;

    Float_t xCornerL=-1e5;
    Float_t lengthL=-1e5;
    Float_t yCornerL=-1e5;
    Float_t rxCornerL=1e-5;
    if(cell>0) {
	xCornerL = fGeomCellPar->getX(module,cell-1);
	lengthL  = fGeomCellPar->getLength(module,cell-1);
	yCornerL = fGeomCellPar->getY(module,cell-1);
	rxCornerL = xCornerL - lengthL;
    }
    
    Float_t angle1 = 0.;
    Float_t angle2 = 0.;
    if(lengthL>0) {
	angle1 = atan2(xCorner-xCornerL  ,yCorner-yCornerL);
	angle2 = atan2(rxCorner-rxCornerL,yCorner-yCornerL);
	// Check that is not one of the cells that has the outer part flat!
	if(cell<30 && cell>27) {
	    if(xCorner == fGeomCellPar->getX(module,cell+1)) {
                angle1 = 0.;
	    }
	    if(rxCorner == (fGeomCellPar->getX(module,cell+1) - fGeomCellPar->getLength(module,cell+1)) ) {
                angle2 = 0.;
	    }
	}
    } else {
	xCornerL = fGeomCellPar->getX(module,cell+1);
        yCornerL = fGeomCellPar->getY(module,cell+1);
	lengthL  = fGeomCellPar->getLength(module,cell+1);
	rxCornerL = xCornerL + lengthL;
	angle1 = atan2(  xCornerL-xCorner,yCornerL-yCorner);
	angle2 = atan2(rxCornerL-rxCorner,yCornerL-yCorner);
    }

    Float_t distL = -axHit + (xCorner + sin(angle1) * (ayHit-yCorner));
    Float_t distR = axHit - (rxCorner + sin(angle2) * (ayHit-yCorner));

    return distL<distR ? distL : distR;
}

ClassImp(HRpcDigitizer)
 hrpcdigitizer.cc:1
 hrpcdigitizer.cc:2
 hrpcdigitizer.cc:3
 hrpcdigitizer.cc:4
 hrpcdigitizer.cc:5
 hrpcdigitizer.cc:6
 hrpcdigitizer.cc:7
 hrpcdigitizer.cc:8
 hrpcdigitizer.cc:9
 hrpcdigitizer.cc:10
 hrpcdigitizer.cc:11
 hrpcdigitizer.cc:12
 hrpcdigitizer.cc:13
 hrpcdigitizer.cc:14
 hrpcdigitizer.cc:15
 hrpcdigitizer.cc:16
 hrpcdigitizer.cc:17
 hrpcdigitizer.cc:18
 hrpcdigitizer.cc:19
 hrpcdigitizer.cc:20
 hrpcdigitizer.cc:21
 hrpcdigitizer.cc:22
 hrpcdigitizer.cc:23
 hrpcdigitizer.cc:24
 hrpcdigitizer.cc:25
 hrpcdigitizer.cc:26
 hrpcdigitizer.cc:27
 hrpcdigitizer.cc:28
 hrpcdigitizer.cc:29
 hrpcdigitizer.cc:30
 hrpcdigitizer.cc:31
 hrpcdigitizer.cc:32
 hrpcdigitizer.cc:33
 hrpcdigitizer.cc:34
 hrpcdigitizer.cc:35
 hrpcdigitizer.cc:36
 hrpcdigitizer.cc:37
 hrpcdigitizer.cc:38
 hrpcdigitizer.cc:39
 hrpcdigitizer.cc:40
 hrpcdigitizer.cc:41
 hrpcdigitizer.cc:42
 hrpcdigitizer.cc:43
 hrpcdigitizer.cc:44
 hrpcdigitizer.cc:45
 hrpcdigitizer.cc:46
 hrpcdigitizer.cc:47
 hrpcdigitizer.cc:48
 hrpcdigitizer.cc:49
 hrpcdigitizer.cc:50
 hrpcdigitizer.cc:51
 hrpcdigitizer.cc:52
 hrpcdigitizer.cc:53
 hrpcdigitizer.cc:54
 hrpcdigitizer.cc:55
 hrpcdigitizer.cc:56
 hrpcdigitizer.cc:57
 hrpcdigitizer.cc:58
 hrpcdigitizer.cc:59
 hrpcdigitizer.cc:60
 hrpcdigitizer.cc:61
 hrpcdigitizer.cc:62
 hrpcdigitizer.cc:63
 hrpcdigitizer.cc:64
 hrpcdigitizer.cc:65
 hrpcdigitizer.cc:66
 hrpcdigitizer.cc:67
 hrpcdigitizer.cc:68
 hrpcdigitizer.cc:69
 hrpcdigitizer.cc:70
 hrpcdigitizer.cc:71
 hrpcdigitizer.cc:72
 hrpcdigitizer.cc:73
 hrpcdigitizer.cc:74
 hrpcdigitizer.cc:75
 hrpcdigitizer.cc:76
 hrpcdigitizer.cc:77
 hrpcdigitizer.cc:78
 hrpcdigitizer.cc:79
 hrpcdigitizer.cc:80
 hrpcdigitizer.cc:81
 hrpcdigitizer.cc:82
 hrpcdigitizer.cc:83
 hrpcdigitizer.cc:84
 hrpcdigitizer.cc:85
 hrpcdigitizer.cc:86
 hrpcdigitizer.cc:87
 hrpcdigitizer.cc:88
 hrpcdigitizer.cc:89
 hrpcdigitizer.cc:90
 hrpcdigitizer.cc:91
 hrpcdigitizer.cc:92
 hrpcdigitizer.cc:93
 hrpcdigitizer.cc:94
 hrpcdigitizer.cc:95
 hrpcdigitizer.cc:96
 hrpcdigitizer.cc:97
 hrpcdigitizer.cc:98
 hrpcdigitizer.cc:99
 hrpcdigitizer.cc:100
 hrpcdigitizer.cc:101
 hrpcdigitizer.cc:102
 hrpcdigitizer.cc:103
 hrpcdigitizer.cc:104
 hrpcdigitizer.cc:105
 hrpcdigitizer.cc:106
 hrpcdigitizer.cc:107
 hrpcdigitizer.cc:108
 hrpcdigitizer.cc:109
 hrpcdigitizer.cc:110
 hrpcdigitizer.cc:111
 hrpcdigitizer.cc:112
 hrpcdigitizer.cc:113
 hrpcdigitizer.cc:114
 hrpcdigitizer.cc:115
 hrpcdigitizer.cc:116
 hrpcdigitizer.cc:117
 hrpcdigitizer.cc:118
 hrpcdigitizer.cc:119
 hrpcdigitizer.cc:120
 hrpcdigitizer.cc:121
 hrpcdigitizer.cc:122
 hrpcdigitizer.cc:123
 hrpcdigitizer.cc:124
 hrpcdigitizer.cc:125
 hrpcdigitizer.cc:126
 hrpcdigitizer.cc:127
 hrpcdigitizer.cc:128
 hrpcdigitizer.cc:129
 hrpcdigitizer.cc:130
 hrpcdigitizer.cc:131
 hrpcdigitizer.cc:132
 hrpcdigitizer.cc:133
 hrpcdigitizer.cc:134
 hrpcdigitizer.cc:135
 hrpcdigitizer.cc:136
 hrpcdigitizer.cc:137
 hrpcdigitizer.cc:138
 hrpcdigitizer.cc:139
 hrpcdigitizer.cc:140
 hrpcdigitizer.cc:141
 hrpcdigitizer.cc:142
 hrpcdigitizer.cc:143
 hrpcdigitizer.cc:144
 hrpcdigitizer.cc:145
 hrpcdigitizer.cc:146
 hrpcdigitizer.cc:147
 hrpcdigitizer.cc:148
 hrpcdigitizer.cc:149
 hrpcdigitizer.cc:150
 hrpcdigitizer.cc:151
 hrpcdigitizer.cc:152
 hrpcdigitizer.cc:153
 hrpcdigitizer.cc:154
 hrpcdigitizer.cc:155
 hrpcdigitizer.cc:156
 hrpcdigitizer.cc:157
 hrpcdigitizer.cc:158
 hrpcdigitizer.cc:159
 hrpcdigitizer.cc:160
 hrpcdigitizer.cc:161
 hrpcdigitizer.cc:162
 hrpcdigitizer.cc:163
 hrpcdigitizer.cc:164
 hrpcdigitizer.cc:165
 hrpcdigitizer.cc:166
 hrpcdigitizer.cc:167
 hrpcdigitizer.cc:168
 hrpcdigitizer.cc:169
 hrpcdigitizer.cc:170
 hrpcdigitizer.cc:171
 hrpcdigitizer.cc:172
 hrpcdigitizer.cc:173
 hrpcdigitizer.cc:174
 hrpcdigitizer.cc:175
 hrpcdigitizer.cc:176
 hrpcdigitizer.cc:177
 hrpcdigitizer.cc:178
 hrpcdigitizer.cc:179
 hrpcdigitizer.cc:180
 hrpcdigitizer.cc:181
 hrpcdigitizer.cc:182
 hrpcdigitizer.cc:183
 hrpcdigitizer.cc:184
 hrpcdigitizer.cc:185
 hrpcdigitizer.cc:186
 hrpcdigitizer.cc:187
 hrpcdigitizer.cc:188
 hrpcdigitizer.cc:189
 hrpcdigitizer.cc:190
 hrpcdigitizer.cc:191
 hrpcdigitizer.cc:192
 hrpcdigitizer.cc:193
 hrpcdigitizer.cc:194
 hrpcdigitizer.cc:195
 hrpcdigitizer.cc:196
 hrpcdigitizer.cc:197
 hrpcdigitizer.cc:198
 hrpcdigitizer.cc:199
 hrpcdigitizer.cc:200
 hrpcdigitizer.cc:201
 hrpcdigitizer.cc:202
 hrpcdigitizer.cc:203
 hrpcdigitizer.cc:204
 hrpcdigitizer.cc:205
 hrpcdigitizer.cc:206
 hrpcdigitizer.cc:207
 hrpcdigitizer.cc:208
 hrpcdigitizer.cc:209
 hrpcdigitizer.cc:210
 hrpcdigitizer.cc:211
 hrpcdigitizer.cc:212
 hrpcdigitizer.cc:213
 hrpcdigitizer.cc:214
 hrpcdigitizer.cc:215
 hrpcdigitizer.cc:216
 hrpcdigitizer.cc:217
 hrpcdigitizer.cc:218
 hrpcdigitizer.cc:219
 hrpcdigitizer.cc:220
 hrpcdigitizer.cc:221
 hrpcdigitizer.cc:222
 hrpcdigitizer.cc:223
 hrpcdigitizer.cc:224
 hrpcdigitizer.cc:225
 hrpcdigitizer.cc:226
 hrpcdigitizer.cc:227
 hrpcdigitizer.cc:228
 hrpcdigitizer.cc:229
 hrpcdigitizer.cc:230
 hrpcdigitizer.cc:231
 hrpcdigitizer.cc:232
 hrpcdigitizer.cc:233
 hrpcdigitizer.cc:234
 hrpcdigitizer.cc:235
 hrpcdigitizer.cc:236
 hrpcdigitizer.cc:237
 hrpcdigitizer.cc:238
 hrpcdigitizer.cc:239
 hrpcdigitizer.cc:240
 hrpcdigitizer.cc:241
 hrpcdigitizer.cc:242
 hrpcdigitizer.cc:243
 hrpcdigitizer.cc:244
 hrpcdigitizer.cc:245
 hrpcdigitizer.cc:246
 hrpcdigitizer.cc:247
 hrpcdigitizer.cc:248
 hrpcdigitizer.cc:249
 hrpcdigitizer.cc:250
 hrpcdigitizer.cc:251
 hrpcdigitizer.cc:252
 hrpcdigitizer.cc:253
 hrpcdigitizer.cc:254
 hrpcdigitizer.cc:255
 hrpcdigitizer.cc:256
 hrpcdigitizer.cc:257
 hrpcdigitizer.cc:258
 hrpcdigitizer.cc:259
 hrpcdigitizer.cc:260
 hrpcdigitizer.cc:261
 hrpcdigitizer.cc:262
 hrpcdigitizer.cc:263
 hrpcdigitizer.cc:264
 hrpcdigitizer.cc:265
 hrpcdigitizer.cc:266
 hrpcdigitizer.cc:267
 hrpcdigitizer.cc:268
 hrpcdigitizer.cc:269
 hrpcdigitizer.cc:270
 hrpcdigitizer.cc:271
 hrpcdigitizer.cc:272
 hrpcdigitizer.cc:273
 hrpcdigitizer.cc:274
 hrpcdigitizer.cc:275
 hrpcdigitizer.cc:276
 hrpcdigitizer.cc:277
 hrpcdigitizer.cc:278
 hrpcdigitizer.cc:279
 hrpcdigitizer.cc:280
 hrpcdigitizer.cc:281
 hrpcdigitizer.cc:282
 hrpcdigitizer.cc:283
 hrpcdigitizer.cc:284
 hrpcdigitizer.cc:285
 hrpcdigitizer.cc:286
 hrpcdigitizer.cc:287
 hrpcdigitizer.cc:288
 hrpcdigitizer.cc:289
 hrpcdigitizer.cc:290
 hrpcdigitizer.cc:291
 hrpcdigitizer.cc:292
 hrpcdigitizer.cc:293
 hrpcdigitizer.cc:294
 hrpcdigitizer.cc:295
 hrpcdigitizer.cc:296
 hrpcdigitizer.cc:297
 hrpcdigitizer.cc:298
 hrpcdigitizer.cc:299
 hrpcdigitizer.cc:300
 hrpcdigitizer.cc:301
 hrpcdigitizer.cc:302
 hrpcdigitizer.cc:303
 hrpcdigitizer.cc:304
 hrpcdigitizer.cc:305
 hrpcdigitizer.cc:306
 hrpcdigitizer.cc:307
 hrpcdigitizer.cc:308
 hrpcdigitizer.cc:309
 hrpcdigitizer.cc:310
 hrpcdigitizer.cc:311
 hrpcdigitizer.cc:312
 hrpcdigitizer.cc:313
 hrpcdigitizer.cc:314
 hrpcdigitizer.cc:315
 hrpcdigitizer.cc:316
 hrpcdigitizer.cc:317
 hrpcdigitizer.cc:318
 hrpcdigitizer.cc:319
 hrpcdigitizer.cc:320
 hrpcdigitizer.cc:321
 hrpcdigitizer.cc:322
 hrpcdigitizer.cc:323
 hrpcdigitizer.cc:324
 hrpcdigitizer.cc:325
 hrpcdigitizer.cc:326
 hrpcdigitizer.cc:327
 hrpcdigitizer.cc:328
 hrpcdigitizer.cc:329
 hrpcdigitizer.cc:330
 hrpcdigitizer.cc:331
 hrpcdigitizer.cc:332
 hrpcdigitizer.cc:333
 hrpcdigitizer.cc:334
 hrpcdigitizer.cc:335
 hrpcdigitizer.cc:336
 hrpcdigitizer.cc:337
 hrpcdigitizer.cc:338
 hrpcdigitizer.cc:339
 hrpcdigitizer.cc:340
 hrpcdigitizer.cc:341
 hrpcdigitizer.cc:342
 hrpcdigitizer.cc:343
 hrpcdigitizer.cc:344
 hrpcdigitizer.cc:345
 hrpcdigitizer.cc:346
 hrpcdigitizer.cc:347
 hrpcdigitizer.cc:348
 hrpcdigitizer.cc:349
 hrpcdigitizer.cc:350
 hrpcdigitizer.cc:351
 hrpcdigitizer.cc:352
 hrpcdigitizer.cc:353
 hrpcdigitizer.cc:354
 hrpcdigitizer.cc:355
 hrpcdigitizer.cc:356
 hrpcdigitizer.cc:357
 hrpcdigitizer.cc:358
 hrpcdigitizer.cc:359
 hrpcdigitizer.cc:360
 hrpcdigitizer.cc:361
 hrpcdigitizer.cc:362
 hrpcdigitizer.cc:363
 hrpcdigitizer.cc:364
 hrpcdigitizer.cc:365
 hrpcdigitizer.cc:366
 hrpcdigitizer.cc:367
 hrpcdigitizer.cc:368
 hrpcdigitizer.cc:369
 hrpcdigitizer.cc:370
 hrpcdigitizer.cc:371
 hrpcdigitizer.cc:372
 hrpcdigitizer.cc:373
 hrpcdigitizer.cc:374
 hrpcdigitizer.cc:375
 hrpcdigitizer.cc:376
 hrpcdigitizer.cc:377
 hrpcdigitizer.cc:378
 hrpcdigitizer.cc:379
 hrpcdigitizer.cc:380
 hrpcdigitizer.cc:381
 hrpcdigitizer.cc:382
 hrpcdigitizer.cc:383
 hrpcdigitizer.cc:384
 hrpcdigitizer.cc:385
 hrpcdigitizer.cc:386
 hrpcdigitizer.cc:387
 hrpcdigitizer.cc:388
 hrpcdigitizer.cc:389
 hrpcdigitizer.cc:390
 hrpcdigitizer.cc:391
 hrpcdigitizer.cc:392
 hrpcdigitizer.cc:393
 hrpcdigitizer.cc:394
 hrpcdigitizer.cc:395
 hrpcdigitizer.cc:396
 hrpcdigitizer.cc:397
 hrpcdigitizer.cc:398
 hrpcdigitizer.cc:399
 hrpcdigitizer.cc:400
 hrpcdigitizer.cc:401
 hrpcdigitizer.cc:402
 hrpcdigitizer.cc:403
 hrpcdigitizer.cc:404
 hrpcdigitizer.cc:405
 hrpcdigitizer.cc:406
 hrpcdigitizer.cc:407
 hrpcdigitizer.cc:408
 hrpcdigitizer.cc:409
 hrpcdigitizer.cc:410
 hrpcdigitizer.cc:411
 hrpcdigitizer.cc:412
 hrpcdigitizer.cc:413
 hrpcdigitizer.cc:414
 hrpcdigitizer.cc:415
 hrpcdigitizer.cc:416
 hrpcdigitizer.cc:417
 hrpcdigitizer.cc:418
 hrpcdigitizer.cc:419
 hrpcdigitizer.cc:420
 hrpcdigitizer.cc:421
 hrpcdigitizer.cc:422
 hrpcdigitizer.cc:423
 hrpcdigitizer.cc:424
 hrpcdigitizer.cc:425
 hrpcdigitizer.cc:426
 hrpcdigitizer.cc:427
 hrpcdigitizer.cc:428
 hrpcdigitizer.cc:429
 hrpcdigitizer.cc:430
 hrpcdigitizer.cc:431
 hrpcdigitizer.cc:432
 hrpcdigitizer.cc:433
 hrpcdigitizer.cc:434
 hrpcdigitizer.cc:435
 hrpcdigitizer.cc:436
 hrpcdigitizer.cc:437
 hrpcdigitizer.cc:438
 hrpcdigitizer.cc:439
 hrpcdigitizer.cc:440
 hrpcdigitizer.cc:441
 hrpcdigitizer.cc:442
 hrpcdigitizer.cc:443
 hrpcdigitizer.cc:444
 hrpcdigitizer.cc:445
 hrpcdigitizer.cc:446
 hrpcdigitizer.cc:447
 hrpcdigitizer.cc:448
 hrpcdigitizer.cc:449
 hrpcdigitizer.cc:450
 hrpcdigitizer.cc:451
 hrpcdigitizer.cc:452
 hrpcdigitizer.cc:453
 hrpcdigitizer.cc:454
 hrpcdigitizer.cc:455
 hrpcdigitizer.cc:456
 hrpcdigitizer.cc:457
 hrpcdigitizer.cc:458
 hrpcdigitizer.cc:459
 hrpcdigitizer.cc:460
 hrpcdigitizer.cc:461
 hrpcdigitizer.cc:462
 hrpcdigitizer.cc:463
 hrpcdigitizer.cc:464
 hrpcdigitizer.cc:465
 hrpcdigitizer.cc:466
 hrpcdigitizer.cc:467
 hrpcdigitizer.cc:468
 hrpcdigitizer.cc:469
 hrpcdigitizer.cc:470
 hrpcdigitizer.cc:471
 hrpcdigitizer.cc:472
 hrpcdigitizer.cc:473
 hrpcdigitizer.cc:474
 hrpcdigitizer.cc:475
 hrpcdigitizer.cc:476
 hrpcdigitizer.cc:477
 hrpcdigitizer.cc:478
 hrpcdigitizer.cc:479
 hrpcdigitizer.cc:480
 hrpcdigitizer.cc:481
 hrpcdigitizer.cc:482
 hrpcdigitizer.cc:483
 hrpcdigitizer.cc:484
 hrpcdigitizer.cc:485
 hrpcdigitizer.cc:486
 hrpcdigitizer.cc:487
 hrpcdigitizer.cc:488
 hrpcdigitizer.cc:489
 hrpcdigitizer.cc:490
 hrpcdigitizer.cc:491
 hrpcdigitizer.cc:492
 hrpcdigitizer.cc:493
 hrpcdigitizer.cc:494
 hrpcdigitizer.cc:495
 hrpcdigitizer.cc:496
 hrpcdigitizer.cc:497
 hrpcdigitizer.cc:498
 hrpcdigitizer.cc:499
 hrpcdigitizer.cc:500
 hrpcdigitizer.cc:501
 hrpcdigitizer.cc:502
 hrpcdigitizer.cc:503
 hrpcdigitizer.cc:504
 hrpcdigitizer.cc:505
 hrpcdigitizer.cc:506
 hrpcdigitizer.cc:507
 hrpcdigitizer.cc:508
 hrpcdigitizer.cc:509
 hrpcdigitizer.cc:510
 hrpcdigitizer.cc:511
 hrpcdigitizer.cc:512
 hrpcdigitizer.cc:513
 hrpcdigitizer.cc:514
 hrpcdigitizer.cc:515
 hrpcdigitizer.cc:516
 hrpcdigitizer.cc:517
 hrpcdigitizer.cc:518
 hrpcdigitizer.cc:519
 hrpcdigitizer.cc:520
 hrpcdigitizer.cc:521
 hrpcdigitizer.cc:522
 hrpcdigitizer.cc:523
 hrpcdigitizer.cc:524
 hrpcdigitizer.cc:525
 hrpcdigitizer.cc:526
 hrpcdigitizer.cc:527
 hrpcdigitizer.cc:528
 hrpcdigitizer.cc:529
 hrpcdigitizer.cc:530
 hrpcdigitizer.cc:531
 hrpcdigitizer.cc:532
 hrpcdigitizer.cc:533
 hrpcdigitizer.cc:534
 hrpcdigitizer.cc:535
 hrpcdigitizer.cc:536
 hrpcdigitizer.cc:537
 hrpcdigitizer.cc:538
 hrpcdigitizer.cc:539
 hrpcdigitizer.cc:540
 hrpcdigitizer.cc:541
 hrpcdigitizer.cc:542
 hrpcdigitizer.cc:543
 hrpcdigitizer.cc:544
 hrpcdigitizer.cc:545
 hrpcdigitizer.cc:546
 hrpcdigitizer.cc:547
 hrpcdigitizer.cc:548
 hrpcdigitizer.cc:549
 hrpcdigitizer.cc:550
 hrpcdigitizer.cc:551
 hrpcdigitizer.cc:552
 hrpcdigitizer.cc:553
 hrpcdigitizer.cc:554
 hrpcdigitizer.cc:555
 hrpcdigitizer.cc:556
 hrpcdigitizer.cc:557
 hrpcdigitizer.cc:558
 hrpcdigitizer.cc:559
 hrpcdigitizer.cc:560
 hrpcdigitizer.cc:561
 hrpcdigitizer.cc:562
 hrpcdigitizer.cc:563
 hrpcdigitizer.cc:564
 hrpcdigitizer.cc:565
 hrpcdigitizer.cc:566
 hrpcdigitizer.cc:567
 hrpcdigitizer.cc:568
 hrpcdigitizer.cc:569
 hrpcdigitizer.cc:570
 hrpcdigitizer.cc:571
 hrpcdigitizer.cc:572
 hrpcdigitizer.cc:573
 hrpcdigitizer.cc:574
 hrpcdigitizer.cc:575
 hrpcdigitizer.cc:576
 hrpcdigitizer.cc:577
 hrpcdigitizer.cc:578
 hrpcdigitizer.cc:579
 hrpcdigitizer.cc:580
 hrpcdigitizer.cc:581
 hrpcdigitizer.cc:582
 hrpcdigitizer.cc:583
 hrpcdigitizer.cc:584
 hrpcdigitizer.cc:585
 hrpcdigitizer.cc:586
 hrpcdigitizer.cc:587
 hrpcdigitizer.cc:588
 hrpcdigitizer.cc:589
 hrpcdigitizer.cc:590
 hrpcdigitizer.cc:591
 hrpcdigitizer.cc:592
 hrpcdigitizer.cc:593
 hrpcdigitizer.cc:594
 hrpcdigitizer.cc:595
 hrpcdigitizer.cc:596
 hrpcdigitizer.cc:597
 hrpcdigitizer.cc:598
 hrpcdigitizer.cc:599
 hrpcdigitizer.cc:600
 hrpcdigitizer.cc:601
 hrpcdigitizer.cc:602
 hrpcdigitizer.cc:603
 hrpcdigitizer.cc:604
 hrpcdigitizer.cc:605
 hrpcdigitizer.cc:606
 hrpcdigitizer.cc:607
 hrpcdigitizer.cc:608
 hrpcdigitizer.cc:609
 hrpcdigitizer.cc:610
 hrpcdigitizer.cc:611
 hrpcdigitizer.cc:612
 hrpcdigitizer.cc:613
 hrpcdigitizer.cc:614
 hrpcdigitizer.cc:615
 hrpcdigitizer.cc:616
 hrpcdigitizer.cc:617
 hrpcdigitizer.cc:618
 hrpcdigitizer.cc:619
 hrpcdigitizer.cc:620
 hrpcdigitizer.cc:621
 hrpcdigitizer.cc:622
 hrpcdigitizer.cc:623
 hrpcdigitizer.cc:624
 hrpcdigitizer.cc:625
 hrpcdigitizer.cc:626
 hrpcdigitizer.cc:627
 hrpcdigitizer.cc:628
 hrpcdigitizer.cc:629
 hrpcdigitizer.cc:630
 hrpcdigitizer.cc:631
 hrpcdigitizer.cc:632
 hrpcdigitizer.cc:633
 hrpcdigitizer.cc:634
 hrpcdigitizer.cc:635
 hrpcdigitizer.cc:636
 hrpcdigitizer.cc:637
 hrpcdigitizer.cc:638
 hrpcdigitizer.cc:639
 hrpcdigitizer.cc:640
 hrpcdigitizer.cc:641
 hrpcdigitizer.cc:642
 hrpcdigitizer.cc:643
 hrpcdigitizer.cc:644
 hrpcdigitizer.cc:645
 hrpcdigitizer.cc:646
 hrpcdigitizer.cc:647
 hrpcdigitizer.cc:648
 hrpcdigitizer.cc:649
 hrpcdigitizer.cc:650
 hrpcdigitizer.cc:651
 hrpcdigitizer.cc:652
 hrpcdigitizer.cc:653
 hrpcdigitizer.cc:654
 hrpcdigitizer.cc:655
 hrpcdigitizer.cc:656
 hrpcdigitizer.cc:657
 hrpcdigitizer.cc:658
 hrpcdigitizer.cc:659
 hrpcdigitizer.cc:660
 hrpcdigitizer.cc:661
 hrpcdigitizer.cc:662
 hrpcdigitizer.cc:663
 hrpcdigitizer.cc:664
 hrpcdigitizer.cc:665
 hrpcdigitizer.cc:666
 hrpcdigitizer.cc:667
 hrpcdigitizer.cc:668
 hrpcdigitizer.cc:669
 hrpcdigitizer.cc:670
 hrpcdigitizer.cc:671
 hrpcdigitizer.cc:672
 hrpcdigitizer.cc:673
 hrpcdigitizer.cc:674
 hrpcdigitizer.cc:675
 hrpcdigitizer.cc:676
 hrpcdigitizer.cc:677
 hrpcdigitizer.cc:678
 hrpcdigitizer.cc:679
 hrpcdigitizer.cc:680
 hrpcdigitizer.cc:681
 hrpcdigitizer.cc:682
 hrpcdigitizer.cc:683
 hrpcdigitizer.cc:684
 hrpcdigitizer.cc:685
 hrpcdigitizer.cc:686
 hrpcdigitizer.cc:687
 hrpcdigitizer.cc:688
 hrpcdigitizer.cc:689
 hrpcdigitizer.cc:690
 hrpcdigitizer.cc:691
 hrpcdigitizer.cc:692
 hrpcdigitizer.cc:693
 hrpcdigitizer.cc:694
 hrpcdigitizer.cc:695
 hrpcdigitizer.cc:696
 hrpcdigitizer.cc:697
 hrpcdigitizer.cc:698
 hrpcdigitizer.cc:699
 hrpcdigitizer.cc:700
 hrpcdigitizer.cc:701
 hrpcdigitizer.cc:702
 hrpcdigitizer.cc:703
 hrpcdigitizer.cc:704
 hrpcdigitizer.cc:705
 hrpcdigitizer.cc:706
 hrpcdigitizer.cc:707
 hrpcdigitizer.cc:708
 hrpcdigitizer.cc:709
 hrpcdigitizer.cc:710
 hrpcdigitizer.cc:711
 hrpcdigitizer.cc:712
 hrpcdigitizer.cc:713
 hrpcdigitizer.cc:714
 hrpcdigitizer.cc:715
 hrpcdigitizer.cc:716
 hrpcdigitizer.cc:717
 hrpcdigitizer.cc:718
 hrpcdigitizer.cc:719
 hrpcdigitizer.cc:720
 hrpcdigitizer.cc:721
 hrpcdigitizer.cc:722
 hrpcdigitizer.cc:723
 hrpcdigitizer.cc:724
 hrpcdigitizer.cc:725
 hrpcdigitizer.cc:726
 hrpcdigitizer.cc:727
 hrpcdigitizer.cc:728
 hrpcdigitizer.cc:729
 hrpcdigitizer.cc:730
 hrpcdigitizer.cc:731
 hrpcdigitizer.cc:732
 hrpcdigitizer.cc:733
 hrpcdigitizer.cc:734
 hrpcdigitizer.cc:735
 hrpcdigitizer.cc:736
 hrpcdigitizer.cc:737
 hrpcdigitizer.cc:738
 hrpcdigitizer.cc:739
 hrpcdigitizer.cc:740
 hrpcdigitizer.cc:741
 hrpcdigitizer.cc:742
 hrpcdigitizer.cc:743
 hrpcdigitizer.cc:744
 hrpcdigitizer.cc:745
 hrpcdigitizer.cc:746
 hrpcdigitizer.cc:747
 hrpcdigitizer.cc:748
 hrpcdigitizer.cc:749
 hrpcdigitizer.cc:750
 hrpcdigitizer.cc:751
 hrpcdigitizer.cc:752
 hrpcdigitizer.cc:753
 hrpcdigitizer.cc:754
 hrpcdigitizer.cc:755
 hrpcdigitizer.cc:756
 hrpcdigitizer.cc:757
 hrpcdigitizer.cc:758
 hrpcdigitizer.cc:759
 hrpcdigitizer.cc:760
 hrpcdigitizer.cc:761
 hrpcdigitizer.cc:762
 hrpcdigitizer.cc:763
 hrpcdigitizer.cc:764
 hrpcdigitizer.cc:765
 hrpcdigitizer.cc:766
 hrpcdigitizer.cc:767
 hrpcdigitizer.cc:768
 hrpcdigitizer.cc:769
 hrpcdigitizer.cc:770
 hrpcdigitizer.cc:771
 hrpcdigitizer.cc:772
 hrpcdigitizer.cc:773
 hrpcdigitizer.cc:774
 hrpcdigitizer.cc:775
 hrpcdigitizer.cc:776
 hrpcdigitizer.cc:777
 hrpcdigitizer.cc:778
 hrpcdigitizer.cc:779
 hrpcdigitizer.cc:780
 hrpcdigitizer.cc:781
 hrpcdigitizer.cc:782
 hrpcdigitizer.cc:783
 hrpcdigitizer.cc:784
 hrpcdigitizer.cc:785
 hrpcdigitizer.cc:786
 hrpcdigitizer.cc:787
 hrpcdigitizer.cc:788
 hrpcdigitizer.cc:789
 hrpcdigitizer.cc:790
 hrpcdigitizer.cc:791
 hrpcdigitizer.cc:792
 hrpcdigitizer.cc:793
 hrpcdigitizer.cc:794
 hrpcdigitizer.cc:795
 hrpcdigitizer.cc:796
 hrpcdigitizer.cc:797
 hrpcdigitizer.cc:798
 hrpcdigitizer.cc:799
 hrpcdigitizer.cc:800
 hrpcdigitizer.cc:801
 hrpcdigitizer.cc:802
 hrpcdigitizer.cc:803
 hrpcdigitizer.cc:804
 hrpcdigitizer.cc:805
 hrpcdigitizer.cc:806
 hrpcdigitizer.cc:807
 hrpcdigitizer.cc:808
 hrpcdigitizer.cc:809
 hrpcdigitizer.cc:810
 hrpcdigitizer.cc:811
 hrpcdigitizer.cc:812
 hrpcdigitizer.cc:813
 hrpcdigitizer.cc:814
 hrpcdigitizer.cc:815
 hrpcdigitizer.cc:816
 hrpcdigitizer.cc:817
 hrpcdigitizer.cc:818
 hrpcdigitizer.cc:819
 hrpcdigitizer.cc:820
 hrpcdigitizer.cc:821
 hrpcdigitizer.cc:822
 hrpcdigitizer.cc:823
 hrpcdigitizer.cc:824
 hrpcdigitizer.cc:825
 hrpcdigitizer.cc:826
 hrpcdigitizer.cc:827
 hrpcdigitizer.cc:828
 hrpcdigitizer.cc:829
 hrpcdigitizer.cc:830
 hrpcdigitizer.cc:831
 hrpcdigitizer.cc:832
 hrpcdigitizer.cc:833
 hrpcdigitizer.cc:834
 hrpcdigitizer.cc:835
 hrpcdigitizer.cc:836
 hrpcdigitizer.cc:837
 hrpcdigitizer.cc:838
 hrpcdigitizer.cc:839
 hrpcdigitizer.cc:840
 hrpcdigitizer.cc:841
 hrpcdigitizer.cc:842
 hrpcdigitizer.cc:843
 hrpcdigitizer.cc:844
 hrpcdigitizer.cc:845
 hrpcdigitizer.cc:846
 hrpcdigitizer.cc:847
 hrpcdigitizer.cc:848
 hrpcdigitizer.cc:849
 hrpcdigitizer.cc:850
 hrpcdigitizer.cc:851
 hrpcdigitizer.cc:852
 hrpcdigitizer.cc:853
 hrpcdigitizer.cc:854
 hrpcdigitizer.cc:855
 hrpcdigitizer.cc:856
 hrpcdigitizer.cc:857
 hrpcdigitizer.cc:858
 hrpcdigitizer.cc:859
 hrpcdigitizer.cc:860
 hrpcdigitizer.cc:861
 hrpcdigitizer.cc:862
 hrpcdigitizer.cc:863
 hrpcdigitizer.cc:864
 hrpcdigitizer.cc:865
 hrpcdigitizer.cc:866
 hrpcdigitizer.cc:867
 hrpcdigitizer.cc:868
 hrpcdigitizer.cc:869
 hrpcdigitizer.cc:870
 hrpcdigitizer.cc:871
 hrpcdigitizer.cc:872
 hrpcdigitizer.cc:873
 hrpcdigitizer.cc:874
 hrpcdigitizer.cc:875
 hrpcdigitizer.cc:876
 hrpcdigitizer.cc:877
 hrpcdigitizer.cc:878
 hrpcdigitizer.cc:879
 hrpcdigitizer.cc:880
 hrpcdigitizer.cc:881
 hrpcdigitizer.cc:882
 hrpcdigitizer.cc:883
 hrpcdigitizer.cc:884
 hrpcdigitizer.cc:885
 hrpcdigitizer.cc:886
 hrpcdigitizer.cc:887
 hrpcdigitizer.cc:888
 hrpcdigitizer.cc:889
 hrpcdigitizer.cc:890
 hrpcdigitizer.cc:891
 hrpcdigitizer.cc:892
 hrpcdigitizer.cc:893
 hrpcdigitizer.cc:894
 hrpcdigitizer.cc:895
 hrpcdigitizer.cc:896
 hrpcdigitizer.cc:897
 hrpcdigitizer.cc:898
 hrpcdigitizer.cc:899
 hrpcdigitizer.cc:900
 hrpcdigitizer.cc:901
 hrpcdigitizer.cc:902
 hrpcdigitizer.cc:903
 hrpcdigitizer.cc:904
 hrpcdigitizer.cc:905
 hrpcdigitizer.cc:906
 hrpcdigitizer.cc:907
 hrpcdigitizer.cc:908
 hrpcdigitizer.cc:909
 hrpcdigitizer.cc:910
 hrpcdigitizer.cc:911
 hrpcdigitizer.cc:912
 hrpcdigitizer.cc:913
 hrpcdigitizer.cc:914
 hrpcdigitizer.cc:915
 hrpcdigitizer.cc:916
 hrpcdigitizer.cc:917
 hrpcdigitizer.cc:918
 hrpcdigitizer.cc:919
 hrpcdigitizer.cc:920
 hrpcdigitizer.cc:921
 hrpcdigitizer.cc:922
 hrpcdigitizer.cc:923
 hrpcdigitizer.cc:924
 hrpcdigitizer.cc:925
 hrpcdigitizer.cc:926
 hrpcdigitizer.cc:927
 hrpcdigitizer.cc:928
 hrpcdigitizer.cc:929
 hrpcdigitizer.cc:930
 hrpcdigitizer.cc:931
 hrpcdigitizer.cc:932
 hrpcdigitizer.cc:933
 hrpcdigitizer.cc:934
 hrpcdigitizer.cc:935
 hrpcdigitizer.cc:936
 hrpcdigitizer.cc:937
 hrpcdigitizer.cc:938
 hrpcdigitizer.cc:939
 hrpcdigitizer.cc:940
 hrpcdigitizer.cc:941
 hrpcdigitizer.cc:942
 hrpcdigitizer.cc:943
 hrpcdigitizer.cc:944
 hrpcdigitizer.cc:945
 hrpcdigitizer.cc:946
 hrpcdigitizer.cc:947
 hrpcdigitizer.cc:948
 hrpcdigitizer.cc:949
 hrpcdigitizer.cc:950
 hrpcdigitizer.cc:951
 hrpcdigitizer.cc:952
 hrpcdigitizer.cc:953
 hrpcdigitizer.cc:954
 hrpcdigitizer.cc:955
 hrpcdigitizer.cc:956
 hrpcdigitizer.cc:957
 hrpcdigitizer.cc:958
 hrpcdigitizer.cc:959
 hrpcdigitizer.cc:960
 hrpcdigitizer.cc:961
 hrpcdigitizer.cc:962
 hrpcdigitizer.cc:963
 hrpcdigitizer.cc:964
 hrpcdigitizer.cc:965
 hrpcdigitizer.cc:966
 hrpcdigitizer.cc:967
 hrpcdigitizer.cc:968
 hrpcdigitizer.cc:969
 hrpcdigitizer.cc:970
 hrpcdigitizer.cc:971
 hrpcdigitizer.cc:972
 hrpcdigitizer.cc:973
 hrpcdigitizer.cc:974
 hrpcdigitizer.cc:975
 hrpcdigitizer.cc:976
 hrpcdigitizer.cc:977
 hrpcdigitizer.cc:978
 hrpcdigitizer.cc:979
 hrpcdigitizer.cc:980
 hrpcdigitizer.cc:981
 hrpcdigitizer.cc:982
 hrpcdigitizer.cc:983
 hrpcdigitizer.cc:984
 hrpcdigitizer.cc:985
 hrpcdigitizer.cc:986
 hrpcdigitizer.cc:987
 hrpcdigitizer.cc:988
 hrpcdigitizer.cc:989
 hrpcdigitizer.cc:990
 hrpcdigitizer.cc:991
 hrpcdigitizer.cc:992
 hrpcdigitizer.cc:993
 hrpcdigitizer.cc:994
 hrpcdigitizer.cc:995
 hrpcdigitizer.cc:996
 hrpcdigitizer.cc:997
 hrpcdigitizer.cc:998
 hrpcdigitizer.cc:999
 hrpcdigitizer.cc:1000
 hrpcdigitizer.cc:1001
 hrpcdigitizer.cc:1002
 hrpcdigitizer.cc:1003
 hrpcdigitizer.cc:1004
 hrpcdigitizer.cc:1005
 hrpcdigitizer.cc:1006
 hrpcdigitizer.cc:1007
 hrpcdigitizer.cc:1008
 hrpcdigitizer.cc:1009
 hrpcdigitizer.cc:1010
 hrpcdigitizer.cc:1011
 hrpcdigitizer.cc:1012
 hrpcdigitizer.cc:1013
 hrpcdigitizer.cc:1014
 hrpcdigitizer.cc:1015
 hrpcdigitizer.cc:1016
 hrpcdigitizer.cc:1017
 hrpcdigitizer.cc:1018
 hrpcdigitizer.cc:1019
 hrpcdigitizer.cc:1020
 hrpcdigitizer.cc:1021
 hrpcdigitizer.cc:1022
 hrpcdigitizer.cc:1023
 hrpcdigitizer.cc:1024
 hrpcdigitizer.cc:1025
 hrpcdigitizer.cc:1026
 hrpcdigitizer.cc:1027
 hrpcdigitizer.cc:1028
 hrpcdigitizer.cc:1029
 hrpcdigitizer.cc:1030
 hrpcdigitizer.cc:1031
 hrpcdigitizer.cc:1032
 hrpcdigitizer.cc:1033
 hrpcdigitizer.cc:1034
 hrpcdigitizer.cc:1035
 hrpcdigitizer.cc:1036
 hrpcdigitizer.cc:1037
 hrpcdigitizer.cc:1038
 hrpcdigitizer.cc:1039
 hrpcdigitizer.cc:1040
 hrpcdigitizer.cc:1041
 hrpcdigitizer.cc:1042
 hrpcdigitizer.cc:1043
 hrpcdigitizer.cc:1044
 hrpcdigitizer.cc:1045
 hrpcdigitizer.cc:1046
 hrpcdigitizer.cc:1047
 hrpcdigitizer.cc:1048
 hrpcdigitizer.cc:1049
 hrpcdigitizer.cc:1050
 hrpcdigitizer.cc:1051
 hrpcdigitizer.cc:1052
 hrpcdigitizer.cc:1053
 hrpcdigitizer.cc:1054
 hrpcdigitizer.cc:1055
 hrpcdigitizer.cc:1056
 hrpcdigitizer.cc:1057
 hrpcdigitizer.cc:1058
 hrpcdigitizer.cc:1059
 hrpcdigitizer.cc:1060
 hrpcdigitizer.cc:1061
 hrpcdigitizer.cc:1062
 hrpcdigitizer.cc:1063
 hrpcdigitizer.cc:1064
 hrpcdigitizer.cc:1065
 hrpcdigitizer.cc:1066
 hrpcdigitizer.cc:1067
 hrpcdigitizer.cc:1068
 hrpcdigitizer.cc:1069
 hrpcdigitizer.cc:1070
 hrpcdigitizer.cc:1071
 hrpcdigitizer.cc:1072
 hrpcdigitizer.cc:1073
 hrpcdigitizer.cc:1074