TestTrack Class Reference

#include <TestTrack.h>

Inheritance diagram for TestTrack:

Public Member Functions
	TestTrack (const std::string &name, ISvcLocator *pSvcLocator)
	~TestTrack ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
void	reset ()
void	reset_hit ()
void	reset_cluster_1d ()
void	reset_cluster_2d ()
void	reset_map ()
void	reset_track ()

Detailed Description

Definition at line 28 of file TestTrack.h.

Constructor & Destructor Documentation

TestTrack()

TestTrack::TestTrack	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Definition at line 46 of file TestTrack.cxx.

                                                                   :
    Algorithm(name,pSvcLocator){   
 
  declareProperty("selGoodDigi",m_selGoodDigi=1);
  declareProperty("minDigiTime",m_minDigiTime=-8875);
  declareProperty("maxDigiTime",m_maxDigiTime=-8562);
  declareProperty("minQDigi",myQMin=0.0);
  declareProperty("LUTfile", lutfile = "/bes3fs/cgemCosmic/data/CGEM_cosmic_look_up_table_from_17_to_17.root");
  declareProperty("align_flag", align_flag = false);
 
  
}

~TestTrack()

TestTrack::~TestTrack

(

)

Definition at line 59 of file TestTrack.cxx.

                     {
  // delete m_SvcCgem;
  // delete f;
  // delete Tdigi;  
  // delete anode;
  // delete tree;
  // delete output;
  delete lutreader;  
}

Member Function Documentation

execute()

StatusCode TestTrack::execute

(

)

cout << "1D_CLUSTER index " << clusterid << " or " << ncluster << " layer " << layerid << " sheet " << sheetid << " view " << cluster_1d_view[ncluster] << endl; cout << " from " << flagB << " to " << flagE << endl; cout << "hits: ";

cout << "2D_CLUSTER index " << clusterid << " or " << ncluster << " layer " << layerid << " sheet " << sheetid << " view " << cluster_2d_view[ncluster] << endl; cout << " idx " << flagB << " idv " << flagE << endl;

cout << "track id " << track->trackId() << endl; cout << "dr " << track->helix(0) << endl; cout << "phi0 " << track->helix(1) << endl; cout << "dz " << track->helix(3) << endl; cout << "tanL " << track->helix(4) << endl;

Definition at line 440 of file TestTrack.cxx.

                             {
  
  MsgStream log(msgSvc(), name());
 
  //  if(event%1000==0) cout << "--------->TestTrack::execute " << event << endl;
  reset();
 
  //interface to event data service
  ISvcLocator* svcLocator = Gaudi::svcLocator();
  StatusCode sc=svcLocator->service("EventDataSvc", m_evtSvc);
  if (sc.isFailure())
    cout<<"Could not accesss EventDataSvc!"<<endl;
  // -------------------------
  //retrieve CGEM hits from TDS
  SmartDataPtr<CgemDigiCol> aDigiCol(m_evtSvc,"/Event/Digi/CgemDigiCol");
  if(!aDigiCol)
    cout<<"Could not retrieve CGEM digi collection"<<endl;
  nhit = aDigiCol->size();
  // cout << "total hit " << nhit << endl;
 
  // loop on hits
  int ihit=0;
 
  CgemDigiCol::iterator iDigiCol;
  for(iDigiCol=aDigiCol->begin(); iDigiCol!=aDigiCol->end(); iDigiCol++)
    {
      const Identifier ident = (*iDigiCol)->identify();
      int strip = CgemID::strip(ident);
      int layer = CgemID::layer(ident);
      int sheet = CgemID::sheet(ident);
      int view = 1;
      bool is_xstrip = CgemID::is_xstrip(ident);
      if(is_xstrip == true) view = 0;
      double charge = (*iDigiCol)->getCharge_fc();
      double time = (*iDigiCol)->getTime_ns();
 
      hit_strip[ihit] = strip;
      hit_layer[ihit] = layer;
      hit_sheet[ihit] = sheet;
      hit_view[ihit] = view;
      hit_t[ihit] = time;
      hit_q[ihit] = charge;
 
      anode = m_SvcCgem->getReadoutPlane(layer, sheet);
      if(view == 1)  hit_length[ihit] = anode->getVStripLength(strip);
      else hit_length[ihit] = anode->getLength();
 
      int channel = lutreader->GetChannel(layer, sheet, view, strip);
      int roc = lutreader->GetROC(layer, sheet, view, strip);
      int feb = lutreader->GetFEB(layer, sheet, view, strip);
      int tiger = lutreader->GetTIGER(layer, sheet, view, strip);
      int chip = lutreader->GetChip(layer, sheet, view, strip);
      int quality = lutreader->GetQuality(layer, sheet, view, strip);
 
      hit_channel[ihit] = channel;
      hit_roc[ihit] = roc;
      hit_feb[ihit] = feb;
      hit_tiger[ihit] = tiger;
      hit_chip[ihit] = chip;
      hit_quality[ihit] = quality;
      
      if(selDigi(iDigiCol, m_selGoodDigi)==true) {
    hit_selgooddigi[ihit] = 1;
 
        // cout << "HIT " << ihit << " strip " << strip << " layer " << layer << " sheet " << sheet << " view " << view << endl; 
        // map strips to hits (maybe more hits for the same strip)
    std::map<int, std::vector < int > > *map_strip_to_hit = GetStripToHitMap(layer, sheet, view);
    std::map<int, std::vector < int > >::iterator it1 = map_strip_to_hit->find(strip);
        if (it1 != map_strip_to_hit->end()) {
          it1->second.push_back(ihit);
        }
        else {
      std::vector< int > hitlist;
          hitlist.push_back(ihit);
      std::pair<int, std::vector < int> > pair(strip, hitlist);
          map_strip_to_hit->insert(pair);
        }
      }
      // -------------------------------------------------------- 
      ihit++;
    }
 
 
 
  // -------------------------------------------------------------------  
  //retrieve CGEM clusters from TDS
  SmartDataPtr<RecCgemClusterCol> aClusterCol(m_evtSvc,"/Event/Recon/RecCgemClusterCol");
  if(!aClusterCol)
    cout<<"Could not retrieve CGEM cluster collection"<<endl;
  int nclu = aClusterCol->size();
  //cout << "total cluster " << nclu << endl;
  if(nclu > MAXNOFCLUSTERS) {
    std::cout << "nclu " << nclu << std::endl;
    nclu = MAXNOFCLUSTERS; // CHECK HACK
  }
 
  int nclusterx = 0;
  int nclusterv = 0;
  int nclusterxv = 0;
 
  int tmp_cluster_L1_S1 = -1;
  int tmp_cluster_L2_S1 = -1;
  int tmp_cluster_L2_S2 = -1;
  double tmp_charge_L1_S1 = 0.;
  double tmp_charge_L2_S1 = 0.;
  double tmp_charge_L2_S2 = 0.;
 
  ncluster = 0;
 
  RecCgemClusterCol::iterator iClusterCol;
  for(iClusterCol=aClusterCol->begin(); iClusterCol!=aClusterCol->end(); iClusterCol++)
    {
 
      if(ncluster==MAXNOFCLUSTERS) break;
 
      int flag = (*iClusterCol)->getflag(); // 0=x 1=v 2=xv 
      int clusterid = (*iClusterCol)->getclusterid();
      int trkid = (*iClusterCol)->getTrkId();
      int layerid = (*iClusterCol)->getlayerid();
      int sheetid = (*iClusterCol)->getsheetid();
      double edep = (*iClusterCol)->getenergydeposit();
      double phi = (*iClusterCol)->getrecphi();
      double v = (*iClusterCol)->getrecv();
      double z = (*iClusterCol)->getRecZ();
      double phi_cc = (*iClusterCol)->getrecphi_CC();
      double v_cc = (*iClusterCol)->getrecv_CC();
      double z_cc = (*iClusterCol)->getRecZ_CC();
      double phi_tpc = (*iClusterCol)->getrecphi_mTPC();
      double v_tpc = (*iClusterCol)->getrecv_mTPC();
      double z_tpc = (*iClusterCol)->getRecZ_mTPC();
      double a_tpc = 0; //(*iClusterCol)->getparamA_mTPC(); CHECK
      double b_tpc = 0; //(*iClusterCol)->getparamB_mTPC(); CHECK
 
      if(sheetid == -1)  {
    ncluster++;
    continue; // CHECK HACK FOR NOW
      }
 
      // anode mid gap radius
      anode = m_SvcCgem->getReadoutPlane(layerid, sheetid);
      double anode_mid_gap = anode->getMidRAtGap();
 
      // beginning and ending flags
      // if 2D cluster --> they are the x & v 1D clusters
      // if 1D cluster --> they are the first and last contigous strips
      int flagB = (*iClusterCol)->getclusterflagb();
      int flagE = (*iClusterCol)->getclusterflage();
      // ------------------------------------------------------------------- 1D cluster
      // positions CC & uTPC 
      if(flag==0 || flag == 1) {
    cluster_1d_ID[ncluster] = clusterid;
    // time & charge
    cluster_1d_t[ncluster] = 0; // CHECK
    cluster_1d_q[ncluster] = edep;
    // layer/sheet/view 
    cluster_1d_layerid[ncluster] = layerid;
    cluster_1d_sheetid[ncluster] = sheetid;
    cluster_1d_view[ncluster] = flag;
    cluster_1d_r[ncluster] = anode_mid_gap;
    cluster_1d_phi[ncluster] = phi;
    cluster_1d_phi_cc[ncluster] = phi_cc;
    cluster_1d_phi_tpc[ncluster] = phi_tpc;
    cluster_1d_v[ncluster] = v;
    cluster_1d_v_cc[ncluster] = v_cc;
    cluster_1d_v_tpc[ncluster] = v_tpc;
    cluster_1d_a_tpc[ncluster] = a_tpc;
    cluster_1d_b_tpc[ncluster] = b_tpc;
    // from strip1 to strip2
    cluster_1d_strip1[ncluster] = flagB;
    cluster_1d_strip2[ncluster] = flagE;
    int size = flagE - flagB + 1;
    cluster_1d_size[ncluster] = size;
 
    // get the hits
    std::map<int, std::vector < int > > *read_map_strip_to_hit = GetStripToHitMap(layerid, sheetid, flag);
    std::map<int, std::vector < int > >::iterator it2;
    /**
       cout << "1D_CLUSTER index " << clusterid << " or " << ncluster
       << " layer " << layerid << " sheet " << sheetid
       << " view " << cluster_1d_view[ncluster] << endl; 
       cout << " from " << flagB << " to " << flagE << endl;
       cout << "hits: ";
    **/
 
    for(int istrip = 0; istrip < size; istrip++) {
      int stripid = flagB + istrip;
      it2 = read_map_strip_to_hit->find(stripid);
      std::vector< int > hitlist = it2->second;
      int size_hitlist = hitlist.size();
      cluster_1d_hitindex[ncluster][istrip] = hitlist[size_hitlist-1]; // take only the first hit CHECK THIS HAS TO BE CHANGED!
    }
    // -----------------
    ncluster_1d++;
      }
      // ----------
      else if(flag==2 || flag==3) { // ------------------------------------- 2D - xv view
    cluster_2d_ID[ncluster] = clusterid;
    // time & charge
    cluster_2d_t[ncluster] = 0; // CHECK
    cluster_2d_q[ncluster] = edep;
    // layer/sheet/view
    cluster_2d_layerid[ncluster] = layerid;
    cluster_2d_sheetid[ncluster] = sheetid;
    if(layerid==0 && phi>0) cluster_2d_sheetid[ncluster] = 1;
    cluster_2d_view[ncluster] = flag;
    cluster_2d_r[ncluster] = anode_mid_gap;
    cluster_2d_z[ncluster] = z;
    cluster_2d_z_cc[ncluster] = z_cc;
    cluster_2d_z_tpc[ncluster] = z_tpc;
    cluster_2d_phi[ncluster] = phi;
    cluster_2d_phi_cc[ncluster] = phi_cc;
    cluster_2d_phi_tpc[ncluster] = phi_tpc;
    // composing 2D_clusters
    cluster_2d_idx[ncluster] = flagB;
    cluster_2d_idv[ncluster] = flagE;
 
    /**     cout << "2D_CLUSTER index " << clusterid << " or " << ncluster
        << " layer " << layerid << " sheet " << sheetid
        << " view " << cluster_2d_view[ncluster] << endl; 
        cout << " idx " << flagB << " idv " << flagE << endl;
    **/
 
    if(flag==2) {   // HACK THIS
      // find the highest charge cluster
      if(layerid==0) {
        if(edep > tmp_charge_L1_S1) {
          tmp_charge_L1_S1 = edep; tmp_cluster_L1_S1 = ncluster;
        }
      }
      else if(layerid==1 && sheetid==0) {
        if(edep > tmp_charge_L2_S1){
          tmp_charge_L2_S1 = edep; tmp_cluster_L2_S1 = ncluster;
        }
      }
      else if(layerid==1 && sheetid==1) {
        if(edep > tmp_charge_L2_S2){
          tmp_charge_L2_S2 = edep; tmp_cluster_L2_S2 = ncluster;
        }
      }
    }
    // -----------
    ncluster_2d++;
      }
      // cluster counters 
      ncluster++;
      if(flag == 0) {
    nclusterx++;
    if(layerid == 0) ncluster_1d_L1_S1_x++;
    else if(layerid == 1) {
      if(sheetid == 0) ncluster_1d_L2_S1_x++;
      else             ncluster_1d_L2_S2_x++;
    }
      }
      else if(flag == 1) {
    nclusterv++;
    if(layerid == 0) ncluster_1d_L1_S1_v++;
    else if(layerid == 1) {
      if(sheetid == 0) ncluster_1d_L2_S1_v++;
      else             ncluster_1d_L2_S2_v++;
    }
      }
      else if(flag == 2) {
    nclusterxv++;
    if(layerid == 0) ncluster_2d_L1_S1++;
    else if(layerid == 1) {
      if(sheetid == 0) ncluster_2d_L2_S1++;
      else             ncluster_2d_L2_S2++;
    }
      }
      // --------
    }
      
  //  std::cout << "highest charge cluster " << tmp_cluster_L1_S1 << " " << tmp_cluster_L2_S1 << " " << tmp_cluster_L2_S2 << std::endl;
  //    std::cout << "charge " << tmp_charge_L1_S1 << " " << tmp_charge_L2_S1 << " " << tmp_charge_L2_S2 << std::endl;
      
  // set the highest charge 2D - cluster
  if(tmp_cluster_L1_S1!=-1)      cluster_2d_highest[tmp_cluster_L1_S1]=1;
  if(tmp_cluster_L2_S1!=-1)      cluster_2d_highest[tmp_cluster_L2_S1]=1;
  if(tmp_cluster_L2_S2!=-1)      cluster_2d_highest[tmp_cluster_L2_S2]=1;
 
  // -------------------------------------------------------------------
  //retrieve CGEM tracks from TDS
  SmartDataPtr<RecMdcTrackCol> aTrackCol(m_evtSvc,"/Event/Recon/RecMdcTrackCol");
  if(!aTrackCol)  {
    //    cout<<"Could not retrieve CGEM track collection"<<endl;
  }
  else {
    //     cout << "total track " << aTrackCol->size() << endl;
    
    RecMdcTrackCol::iterator iTrackCol;
    for(iTrackCol=aTrackCol->begin(); iTrackCol!=aTrackCol->end(); iTrackCol++)
      {
    RecMdcTrack *track = *iTrackCol;
 
    /**
    cout << "track id " << track->trackId() << endl;
    cout << "dr   " << track->helix(0) << endl;
        cout << "phi0 " << track->helix(1) << endl;
        cout << "dz   " << track->helix(3) << endl;
        cout << "tanL " << track->helix(4) << endl;
    **/
 
    if(track->trackId() != 0) continue;
 
    track_chi2 = track->chi2();
    //  cout << "chi2 " << track_chi2 << endl;
    track_dr = track->helix(0);
    track_phi0 = track->helix(1);
    track_dz = track->helix(3);
    track_tanL = track->helix(4);
    
        ClusterRefVec vecclusters = track->getVecClusters();
        track_nfitpoint = vecclusters.size(); // nof 2D clusters, NOTE! track->getNcluster() gives you the number of 1D clusters
 
    // is the plane under test?
        bool istestplane[2][2];
    for(int ilay=0; ilay<MAXNOFLAYER; ilay++) for(int ishe=0; ishe<MAXNOFSHEET; ishe++) istestplane[ilay][ishe] = true;
 
    for(int iclus=0; iclus < track_nfitpoint; iclus++) {
          RecCgemCluster *tcluster = vecclusters.at(iclus);
      double phi = tcluster->getrecphi();
      double z   = tcluster->getRecZ();
      track_clusterid[iclus] = tcluster->getclusterid();
 
      track_layerid[iclus]   = tcluster->getlayerid();
          track_sheetid[iclus]   = tcluster->getsheetid();
      if(phi > 0) track_sheetid[iclus] = 1;
 
      // cout << "iclus " << iclus << " track_clusterid " <<  track_clusterid[iclus] << " phi " << phi
      //      << " layer " << track_layerid[iclus] << " sheet " << track_sheetid[iclus] << endl;
 
      istestplane[track_layerid[iclus]][track_sheetid[iclus]] = false;
    }
 
    for(int ilay=0; ilay<MAXNOFLAYER; ilay++) {
      for(int ishe=0; ishe<MAXNOFSHEET; ishe++) {
 
        // cout << "situazione ilay " << ilay << " ishe " << ishe << " istestplane " << istestplane[ilay][ishe] << endl;
 
        if(istestplane[ilay][ishe] == true) {
          track_test_layerid = ilay;
              track_test_sheetid = ishe;
        }
      }
    }
 
    // cout << "UNDER TEST layer " << track_test_layerid << " sheet " << track_test_sheetid << endl;
 
    // intersections - poca and intersections are computed in the aligned frame 
    double xP; double yP; double zP;    
    ComputePOCA(xP, yP, zP);
 
    // L1
    double xP1; double yP1; double zP1; double phiP1; double vP1; 
        double xP2; double yP2; double zP2; double phiP2; double vP2;
 
    double angCR_xy_L1, angCR_yz_L1;
 
        bool gotit1 = ComputeIntersection(0, xP1, yP1, zP1, phiP1, vP1, xP2, yP2, zP2, phiP2, vP2, angCR_xy_L1, angCR_yz_L1); //1->up 2->down
 
    ang_xy_L1 = angCR_xy_L1;
    ang_yz_L1 = angCR_yz_L1;
 
    // L2 
    double xP3; double yP3; double zP3; double phiP3; double vP3; 
        double xP4; double yP4; double zP4; double phiP4; double vP4;
 
    double angCR_xy_L2, angCR_yz_L2;
 
    bool gotit2 = ComputeIntersection(1, xP3, yP3, zP3, phiP3, vP3, xP4, yP4, zP4, phiP4, vP4, angCR_xy_L2, angCR_yz_L2); //1->up 2->down
 
    ang_xy_L2 = angCR_xy_L2;
    ang_yz_L2 = angCR_yz_L2;
 
    if(gotit1==false || gotit2==false) cout << "TestTrack: error in intersection calculation. Intersection on L1 " << gotit1  << ", on L2 " << gotit2 << endl;
 
    // output
    // poca
    track_xpoca_glo = xP; track_ypoca_glo = yP; track_zpoca_glo = zP;
    // intersections
        // L1 
    track_x1top_glo = xP1; track_y1top_glo = yP1; track_z1top_glo = zP1; track_phi1top_loc = phiP1;  track_v1top_loc = vP1; 
    track_x1bot_glo = xP2; track_y1bot_glo = yP2; track_z1bot_glo = zP2; track_phi1bot_loc = phiP2;  track_v1bot_loc = vP2;
    // L2
    track_x2top_glo = xP3; track_y2top_glo = yP3; track_z2top_glo = zP3; track_phi2top_loc = phiP3;  track_v2top_loc = vP3;
    track_x2bot_glo = xP4; track_y2bot_glo = yP4; track_z2bot_glo = zP4; track_phi2bot_loc = phiP4;  track_v2bot_loc = vP4;
      }
 
  
  }
  tree->Fill();
  
  event++;
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode TestTrack::finalize

(

)

Definition at line 837 of file TestTrack.cxx.

                              {
    MsgStream log(msgSvc(),name());
    log << MSG::INFO << "TestTrack finalize()" << endreq;
    output->Write();
    output->Close();
    return StatusCode::SUCCESS;
}

initialize()

StatusCode TestTrack::initialize

(

)

Definition at line 402 of file TestTrack.cxx.

                                {
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "TestTrack initialize()" << endreq;
 
 
  // CgemGeomSvc                                                                                                                       
  StatusCode sc;       
  sc = service("CgemGeomSvc", m_SvcCgem);                                                                                        
  if(sc != StatusCode::SUCCESS)  { 
    log << MSG::ERROR << "can not use CgemGeomSvc" << endreq;                                                                   
    return StatusCode::FAILURE;                                                                                                 
  }  
 
  anode = m_SvcCgem->getReadoutPlane(0, 0);
  anode_mid_gap_L1 = anode->getMidRAtGap();
  anode = m_SvcCgem->getReadoutPlane(1, 0);
  anode_mid_gap_L2 = anode->getMidRAtGap();
 
  midplane = m_SvcCgem->getMidDriftPtr();
  alignment = m_SvcCgem->getAlignPtr() ;
 
 
  // LUT
  lutreader = new CgemLUTReader(lutfile);
  lutreader->ReadLUT();
 
  output = new TFile("track.root", "RECREATE");
  tree = new TTree("tree","hit, cluster and track info tree");
  DefineHitTree();
  DefineClusterTree();
  DefineTrackTree();
 
  event=0;
 
  return StatusCode::SUCCESS;
 
}

reset()

void TestTrack::reset

(

)

Definition at line 206 of file TestTrack.cxx.

                      {
  reset_map();
  reset_cluster_1d();
  reset_cluster_2d();
  reset_hit();
  reset_track();
}

Referenced by execute().

reset_cluster_1d()

void TestTrack::reset_cluster_1d

(

)

Definition at line 236 of file TestTrack.cxx.

                                 {
 
  ncluster_1d = 0;
  ncluster_1d_L1_S1_x = 0;
  ncluster_1d_L2_S1_x = 0;
  ncluster_1d_L2_S2_x = 0;
  ncluster_1d_L1_S1_v = 0;
  ncluster_1d_L2_S1_v = 0;
  ncluster_1d_L2_S2_v = 0;
 
  for(int iclu = 0; iclu < MAXNOFCLUSTERS; iclu++)
    {
      cluster_1d_t[iclu] = 0.;
      cluster_1d_q[iclu] = 0.;
      cluster_1d_r[iclu] = 0.;
      cluster_1d_v[iclu] = 0.;
      cluster_1d_phi[iclu] = 0.;
      cluster_1d_v_cc[iclu] = 0.;
      cluster_1d_phi_cc[iclu] = 0.;
      cluster_1d_v_tpc[iclu] = 0.;
      cluster_1d_phi_tpc[iclu] = 0.;
      cluster_1d_a_tpc[iclu] = 0.;
      cluster_1d_b_tpc[iclu] = 0.;
      cluster_1d_layerid[iclu] = -1;
      cluster_1d_sheetid[iclu] = -1;
      cluster_1d_view[iclu] = -1;
      cluster_1d_size[iclu] = -1;
      cluster_1d_strip1[iclu] = -1;
      cluster_1d_strip2[iclu] = -1;
      for(int ihit = 0; ihit < MAXNOFHITS; ihit++) cluster_1d_hitindex[iclu][ihit] = -1;
    }
 
 
 
}

Referenced by reset().

reset_cluster_2d()

void TestTrack::reset_cluster_2d

(

)

Definition at line 272 of file TestTrack.cxx.

                                 {
 
  ncluster_2d = 0;
  ncluster_2d_L1_S1 = 0;
  ncluster_2d_L2_S1 = 0;
  ncluster_2d_L2_S2 = 0;
 
  for(int iclu = 0; iclu < MAXNOFCLUSTERS; iclu++)
    {
      cluster_2d_t[iclu] = 0.;
      cluster_2d_q[iclu] = 0.;
      cluster_2d_r[iclu] = 0.;
      cluster_2d_z[iclu] = 0.;
      cluster_2d_phi[iclu] = 0.;
      cluster_2d_z_cc[iclu] = 0.;
      cluster_2d_phi_cc[iclu] = 0.;
      cluster_2d_z_tpc[iclu] = 0.;
      cluster_2d_phi_tpc[iclu] = 0.;
      cluster_2d_layerid[iclu] = -1;
      cluster_2d_sheetid[iclu] = -1;
      cluster_2d_view[iclu] = -1;
      cluster_2d_idx[iclu] = -1;
      cluster_2d_idv[iclu] = -1;
      cluster_2d_highest[iclu] = -1;
    }
}

Referenced by reset().

reset_hit()

void TestTrack::reset_hit

(

)

Definition at line 214 of file TestTrack.cxx.

                          {
  // event = 0;    
  nhit = 0;
 
  for(int ihit = 0; ihit < MAXNOFHITS; ihit++) {
    hit_strip[ihit] = -1;
    hit_view[ihit] = -1;
    hit_layer[ihit] = -1;
    hit_sheet[ihit] = -1;
    hit_length[ihit] = -1;
    hit_channel[ihit] = -1;
    hit_roc[ihit] = -1;
    hit_feb[ihit] = -1;
    hit_tiger[ihit] = -1;
    hit_chip[ihit] = -1;
    hit_t[ihit] = 0;
    hit_q[ihit] = 0;
    hit_quality[ihit] = 0;
    hit_selgooddigi[ihit] = 0;
 }
}

Referenced by reset().

reset_map()

void TestTrack::reset_map

(

)

Definition at line 299 of file TestTrack.cxx.

                          {
  map_L1_S1_stripx_to_hit.clear();
  map_L2_S1_stripx_to_hit.clear();
  map_L2_S2_stripx_to_hit.clear();
  map_L1_S1_stripv_to_hit.clear();
  map_L2_S1_stripv_to_hit.clear();
  map_L2_S2_stripv_to_hit.clear();
}

Referenced by reset().

reset_track()

void TestTrack::reset_track

(

)

Definition at line 308 of file TestTrack.cxx.

                            {
 
  // parameters
  track_dr = -9999;
  track_phi0 = -9999;
  track_dz = -9999;
  track_tanL = -9999;
  track_chi2 = 9999;
 
  // clusters
  track_nfitpoint = 0;
  for(int iclus=0; iclus < MAXNOFFITPOINT; iclus++) {
    track_clusterid[iclus] = -1;
    track_layerid[iclus] = -1;
    track_sheetid[iclus] = -1;
  }
 
  // planes under test
  track_test_layerid = -1;
  track_test_sheetid = -1;
 
  // poca
  track_xpoca_glo = -9999;
  track_ypoca_glo = -9999;
  track_zpoca_glo = -9999;
 
  // intersections 
  // L1             
  track_x1top_glo = -9999;
  track_y1top_glo = -9999;
  track_z1top_glo = -9999;
  track_x1bot_glo = -9999;
  track_y1bot_glo = -9999;
  track_z1bot_glo = -9999;
  // L2
  track_x2top_glo = -9999;
  track_y2top_glo = -9999;
  track_z2top_glo = -9999;
  track_x2bot_glo = -9999;
  track_y2bot_glo = -9999;
  track_z2bot_glo = -9999;
 
 
}

Referenced by reset().

---

The documentation for this class was generated from the following files:

• TestTrack.h
• TestTrack.cxx