#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>

#include "TObjectTable.h"
#include "TBranch.h"
#include "TFndFeeMap.h"
#include "TFndConst.h"
#include "TFndRdt.h"
#include "TFndHdt.h"
#include "TFndRawEqp.h"
#include "TFndRawSil.h"
#include "TFndHHdr.h"
#include "TFndHSil.h"
#include "TFndHTof.h"
#include "TFndHLmd.h"
#include "TFndHStb.h"
#include "TFndCorbo.h"
#include "TFndTrig.h"
#include "Bytes.h"

//******************************************************************/
//*-------> UNIX only */
//******************************************************************/

#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/types.h>

#include <sys/socket.h>
#include <sys/un.h>

#include <netinet/in.h>
#include <netdb.h>
#include "TObjectTable.h"

ClassImp(TFndRdt);

 TFndRdt::TFndRdt() { 
  phdr = new TFndHHdr();
  pgts = new TFndRawEqp();
  ptof = new TFndRawEqp();
  pism = new TFndRawSil();
  posm = new TFndRawSil();
  plmd = new TFndRawEqp();
  pstb = new TFndRawEqp();
}

 TFndRdt::~TFndRdt() {  
  delete phdr;
  delete pgts;
  delete ptof;
  delete pism; 
  delete posm;
  delete plmd;
  delete pstb;
}

 TFndRdt::TFndRdt(TFndHHdr *hdr, TFndRawEqp *gts, TFndRawEqp *tof, TFndRawSil *ism, TFndRawSil *osm, TFndRawEqp *lmd, TFndRawEqp *stb) {
  phdr = hdr;
  pgts = gts;
  ptof = tof;
  pism = ism;
  posm = osm;
  plmd = lmd;
  pstb = stb;
}

//******************************************************************/
//*                     Build  Gts  Hits  Tree                     */
//******************************************************************/

 void TFndRdt::GtsTree(TFndHdt* fev, TFndFeeMap* fndfeemap) {

  TFndTrig *fTrig = new TFndTrig(this);
  fev->AddTrg(fTrig);
}

//******************************************************************/
//*                     Build  Ism  Hits  Tree                     */
//******************************************************************/

 void TFndRdt::IsmTree(TFndHdt* fev, TFndFeeMap* fndfeemap) {

  TFndRawSil *ism = this->GetIsm();
  for(Int_t k=0; k<TFndConst::kN_CRAMS; k++) {
    Int_t clen = (Int_t) ism->GetCramLen(k);
    if(clen) {
      UInt_t *pcram = ism->GetCram(k);
      UInt_t sect = *(pcram+1);
      UInt_t ncram = ((*pcram)>>0x10)&0xF;
      ncram = (ncram-4)*2+sect;
      //UInt_t addr = *(pcram);
      //printf("Cram %d, Address %X, Section %d, Length %dn",ncram,addr,sect,clen);
      for(Int_t j=3; j<clen; j++) {
        ULong_t stripn = (*(pcram+j)) << 9; 
        stripn = stripn >> 21;
        Int_t nstrip = (Int_t) stripn;
        ULong_t adcv = (*(pcram+j)) << 20; 
        adcv = adcv >> 20;
        Int_t adc = (Int_t) adcv - 200;
	UInt_t noisev = (*(pcram+j)) << 1;
        noisev = noisev >> 24;
	Short_t noise = (Short_t) noisev/10;
        Short_t nmodule = fndfeemap->GetSilModule(ncram);
        Short_t nsection = fndfeemap->GetSilSection(ncram);
	Short_t nhybrid = (Short_t) ncram;
        TFndHSil *hit = new TFndHSil(nhybrid,nmodule,nsection,nstrip,adc,noise);
        fev->AddHit(hit);  
        //hit->Print();
        }
      }
    }

}

//******************************************************************/
//*                     Build  Osm  Hits  Tree                     */
//******************************************************************/

 void TFndRdt::OsmTree(TFndHdt* fev, TFndFeeMap* fndfeemap) {

  TFndRawSil *osm = this->GetOsm();
  for(Int_t k=0; k<TFndConst::kN_CRAMS; k++) {
    Int_t clen = (Int_t) osm->GetCramLen(k);
    if(clen) {
      UInt_t *pcram = osm->GetCram(k);
      UInt_t sect = *(pcram+1);
      UInt_t ncram = ((*pcram)>>0x10)&0xF;
      ncram = (ncram-4)*2+sect;
      //UInt_t addr = *(pcram);
      //printf("Cram %d, Address %X, Section %d, Length %dn",ncram,addr,sect,clen);
      for(Int_t j=3; j<clen; j++) {
        ULong_t stripn = (*(pcram+j)) << 9; 
        stripn = stripn >> 21;
        Int_t nstrip = (Int_t) stripn;
        ULong_t adcv = (*(pcram+j)) << 20; 
        adcv = adcv >> 20;
        Int_t adc = (Int_t) adcv - 200;
	UInt_t noisev = (*(pcram+j)) << 1;
        noisev = noisev >> 24;
	Short_t noise = (Short_t) noisev/10;
        Short_t nmodule = fndfeemap->GetSilModule(ncram);
        Short_t nsection = fndfeemap->GetSilSection(ncram);
	Short_t nhybrid = (Short_t) ncram;
        TFndHSil *hit = new TFndHSil(nhybrid,nmodule,nsection,nstrip,adc,noise);
        fev->AddHit(hit);  
        //hit->Print();
        }
      }
    }

}

//******************************************************************/
//*                     Build  Tof  Hits  Tree                     */
//******************************************************************/

 void TFndRdt::TofTree(TFndHdt* fev, TFndFeeMap* fndfeemap) {

  Int_t n_adc_hit = this->TofAdcHit(fev,fndfeemap);
  Int_t n_tdc_hit = this->TofTdcHit(fev,fndfeemap);
  //  cout << n_adc_hit << " tof ADC hits, " << n_tdc_hit << " tof TDC hits" << endl;

  }


 Int_t TFndRdt::TofAdcHit(TFndHdt* fev, TFndFeeMap* fndfeemap) {

//*--------> TOF hit <----------*/
   TFndHTof *hit;

   UInt_t *ladcptr=0;
   UInt_t ladclen=0;

// ADC equipment
//   cout << "ADC equipment" << endl;

   TFndRawEqp *tofptr = this->GetTof();
//   cout << "length " << endl;
   ladcptr = tofptr->GetEqp(5);
   ladclen = tofptr->GetEqpLen(5);
 
   Int_t n_tof_hit = 0;

    if(ladclen) {
     Int_t tof_adc_cnt;
     Int_t tof_adc_chn;
     Int_t tof_adc_brd;
     Int_t i=0;
     while(i < (Int_t) ladclen-1) {
       if(i>0) { ladcptr++; i++; }
       Int_t n_conv = *ladcptr;
  //            cout << n_conv << " conversions" << endl;
       for(Int_t k=0;k<n_conv;k++) {
	 i++;
         ladcptr++;
         tof_adc_cnt = (Int_t) (*ladcptr)&0xFFF;
         tof_adc_chn = (Int_t) ((*ladcptr)>>0x10)&0x3F;
         tof_adc_brd = (Int_t) ((*ladcptr)>>0x17)&0x1F;
	//         cout << "tof_adc_cnt[" << i <<"] " << tof_adc_cnt << endl;
        // cout << "tof_adc_chn[" << i <<"] " << tof_adc_chn << endl;
        // cout << "tof_adc_brd[" << i <<"] " << tof_adc_brd << endl;
         Int_t tofslb1 = 0;
         Int_t rflag1 = -1;
         if(fndfeemap->IsThere()) {
           tofslb1 = fndfeemap->GetTofAdcSlb(tof_adc_chn);
           rflag1 = fndfeemap->GetTofAdcSide(tof_adc_chn);
           Int_t hit_found = 0;
           for(Int_t j=0; j<n_tof_hit;j++){
             TFndHTof *hadc = fev->GetHTof(j);
             Int_t tofslb = hadc->GetSlab();
             if(tofslb1 >= 101 && tofslb1<=120 && tofslb1 == tofslb){
               hit_found = 1; 
               //cout << "rflag1 = " << rflag1 << endl;
               if(rflag1 == 0)
                 hadc->SetAdcF(tof_adc_cnt);
               else if(rflag1 == 1)
                 hadc->SetAdcR(tof_adc_cnt);
               //hadc->Print();
               break;
               } 
             }

           if(hit_found == 0 && tofslb1 >= 101 && tofslb1<=120) {
//      CREAZIONE DELL'HIT
             Int_t Tflag = 0;
	     //             TFndHTof *hit;
             if(rflag1 == 0)
               Tflag = 1;
             else if(rflag1 == 1)
               Tflag = 2;
             hit = new TFndHTof(tofslb1,tof_adc_cnt,Tflag);
             fev->AddHit(hit);
             n_tof_hit++;
	     //cout << n_tof_hit << "tof hits" << endl;
             //hit->Print(); 
             }
           }
         }
       i++;
       ladcptr++;
       }
     }
  return n_tof_hit;
}
 
 Int_t TFndRdt::TofTdcHit(TFndHdt* fev, TFndFeeMap* fndfeemap) {

//*--------> TOF hit <----------*/

    Int_t n_tof_hit=0;

    UInt_t *ltdcptr = 0;
    UInt_t ltdclen = 0;

//    TDC equipment
//    cout <<"TDC equipment" << endl;

    TFndRawEqp *tofptr = this->GetTof();
    ltdcptr = tofptr->GetEqp(6);
    ltdclen = tofptr->GetEqpLen(6);

    if(ltdclen) {
      Int_t tof_tdc_cnt;
      Int_t tof_tdc_chn; 
      Int_t tof_tdc_brd;
      Int_t i=0;
      while(i < (Int_t) ltdclen-1) {
       if(i>0) { ltdcptr++; i++; }
       Int_t n_conv = *ltdcptr;
       //       cout << n_conv << " conversions" << endl;
        for(Int_t k=0;k<n_conv;k++) {
	 i++;
         ltdcptr++;
         tof_tdc_cnt = (Int_t) (*ltdcptr)&0xFFF;
         tof_tdc_chn = (Int_t) ((*ltdcptr)>>0x10)&0x3F;
         tof_tdc_brd = (Int_t) ((*ltdcptr)>>0x17)&0x1F;

         //cout << "tof_tdc_cnt[" << i << "] = " << tof_tdc_cnt << endl;
         //cout << "tof_tdc_chn[" << i << "] = " << tof_tdc_chn << endl; 
         //cout << "tof_tdc_brd[" << i << "] = " << tof_tdc_brd << endl; 

         Int_t tdcslb1 = 0;
         Int_t rflag1  = -1;
         if(fndfeemap->IsThere()) {

          tdcslb1 = fndfeemap->GetTofTdcSlb(tof_tdc_chn);
          rflag1 = fndfeemap->GetTofTdcSide(tof_tdc_chn); 

          //cout << "tdcslb1 = " << tdcslb1 << endl;
          //cout << "rflag1  = " << rflag1  << endl;
          
          Int_t hit_found = 0;
          n_tof_hit = fev->GetNHTof();
          //cout << "n_tof_hit = " << n_tof_hit << endl;
          for(Int_t j=0;j<n_tof_hit;j++) {
            TFndHTof *htdc = fev->GetHTof(j);
            Int_t tdcslb = htdc->GetSlab();
            if(tdcslb1 >= 101 && tdcslb1 <= 120 && tdcslb1 == tdcslb){
              hit_found = 1;
              if(rflag1 == 0)
                htdc->SetTdcF(tof_tdc_cnt);
              else if(rflag1 == 1)
                htdc->SetTdcR(tof_tdc_cnt);
              break;
              }
            }
          if(hit_found == 0 && tdcslb1 >= 101 && tdcslb1<=120) {

//  CREAZIONE DELL' HIT          
            Int_t Tflag = 0;                   
            TFndHTof *hit;
            if(rflag1 == 0)
              Tflag = 3;
            else if(rflag1 == 1)
              Tflag = 4;
            hit = new TFndHTof(tdcslb1,tof_tdc_cnt,Tflag);    
            fev->AddHit(hit);
            n_tof_hit++;
            //hit->Print();
            }
           }
	  }
        }
      }
    return n_tof_hit;
} 

//******************************************************************/
//*                     Build  Lmd  Hits  Tree                     */
//******************************************************************/

 void TFndRdt::LmdTree(TFndHdt* fev, TFndFeeMap* fndfeemap) {

  Int_t n_adc_hit = this->LmdAdcHit(fev,fndfeemap);
  Int_t n_tdc_hit = this->LmdTdcHit(fev,fndfeemap);
//  cout << n_adc_hit << " lmd ADC hits; " << n_tdc_hit << " lmd TDC hits" << endl;

}

 Int_t TFndRdt::LmdAdcHit(TFndHdt* fev, TFndFeeMap* fndfeemap) {

//*--------> LMD hit <----------*/

   UInt_t *ladcptr=0;
   UInt_t ladclen=0;

// ADC equipment
//   cout << "ADC equipment" << endl;

   TFndRawEqp *lmdptr = this->GetLmd();
   ladcptr = lmdptr->GetEqp(5);
   ladclen = lmdptr->GetEqpLen(5);
   //   lmdptr->PrtEqp(5);

   //   Int_t n_adc_hit = ladclen;
 
   Int_t n_lmd_hit = 0;

   if(ladclen) {
     Int_t lmd_adc_cnt=0;
     Int_t lmd_adc_chn=0;
     Int_t lmd_adc_brd=0;
     Int_t i=0;
     while(i < (Int_t) ladclen-1) {
       if(i>0) { ladcptr++; i++; }
       Int_t n_conv = *ladcptr;
       //cout << n_conv << " conversions" << endl;
       for(Int_t k=0;k<n_conv;k++) {
	i++;
        ladcptr++;
	lmd_adc_cnt = (Int_t) (*ladcptr)&0xFFF;
        lmd_adc_chn = (Int_t) ((*ladcptr)>>0x10)&0x3F;
        lmd_adc_brd = (Int_t) ((*ladcptr)>>0x17)&0x1F;

        //cout << "lmd_adc_cnt " << lmd_adc_cnt << endl;
        //cout << "lmd_adc_brd " << lmd_adc_brd;
        //cout << ", lmd_adc_chn " << lmd_adc_chn << endl;

        Int_t adcdch1 = 0;
        Int_t adcwir1 = 0;
        Int_t rflag1 = -1;
        if(fndfeemap->IsThere()) {

         adcdch1 = fndfeemap->GetLmdAdcDch(lmd_adc_brd,lmd_adc_chn);
         adcwir1 = fndfeemap->GetLmdAdcWire(lmd_adc_brd,lmd_adc_chn);
         rflag1 = fndfeemap->GetLmdAdcSide(lmd_adc_brd,lmd_adc_chn);
             
         Int_t hit_found = 0;
         for(Int_t j=0; j<n_lmd_hit;j++){
           TFndHLmd *hadc = fev->GetHLmd(j);
           Int_t adcdch = hadc->GetCham();
           Int_t adcwir = hadc->GetWire();
           if(adcdch1 != 0 && adcwir1 != 0 && adcdch1 == adcdch && adcwir1 == adcwir){
             hit_found = 1;  
	     //             cout << "Dch" << adcdch1 << ", wire " << adcwir1 << ", flag " << rflag1 << endl;
             if(rflag1 == 1)
               hadc->SetAdcF(lmd_adc_cnt);
             else if(rflag1 == 0)
               hadc->SetAdcR(lmd_adc_cnt);
             //hadc->Print();
             break;
             } 
           }
         if(hit_found == 0 && adcdch1 != 0 && adcwir1 != 0) {
//      CREAZIONE DELL'HIT
           Int_t Tflag = 0;
           TFndHLmd *hit;
           if(rflag1 == 0)
             Tflag = 2;
           else if(rflag1 == 1)
             Tflag = 1;
           
           hit = new TFndHLmd(adcdch1,adcwir1,lmd_adc_cnt,Tflag);
           //cout << "Dch" << adcdch1 << ", wire " << adcwir1 << ", flag " << rflag1 << endl;
           fev->AddHit(hit);
           n_lmd_hit++;
           //hit->Print(); 
           }
         }
        }
      i++;
      ladcptr++;
      }
     }
  return n_lmd_hit;
}
 
 Int_t TFndRdt::LmdTdcHit(TFndHdt* fev, TFndFeeMap* fndfeemap) {

//*--------> LMD hit <----------*/

    Int_t n_lmd_hit=0;

    UInt_t *ltdcptr = 0;
    UInt_t ltdclen = 0;

//  TDC equipment
//  cout <<"TDC equipment" << endl;

    TFndRawEqp *lmdptr = this->GetLmd();
    ltdcptr = lmdptr->GetEqp(7);
    ltdclen = lmdptr->GetEqpLen(7);
    //lmdptr->PrtEqp(7);
    
    //cout << "ltdclen " << ltdclen << endl;
    //    cout << "ltdcptr " << ltdcptr << endl;
    if(ltdclen) {
      Int_t lmd_tdc_cnt;
      Int_t lmd_tdc_chn; 
      Int_t lmd_tdc_brd;
      Int_t lmd_tdc_slt;
      Int_t i=0;
      while(i < (Int_t) ltdclen-1) {
        if(i>0) { ltdcptr++; i++; }
        Int_t n_conv = (*ltdcptr)&0xFFFFFF;
        //Int_t n_cage = ((*ltdcptr)>>0x18)&0xF;
	//        cout << "number of conversions: " << n_conv << endl;
        //cout << "cage number: " << n_cage << endl;
        for(Int_t k=0;k<n_conv;k++) {
	  i++;
          ltdcptr++;
          lmd_tdc_cnt = (Int_t) (*ltdcptr)&0xFFFF;
          lmd_tdc_chn = (Int_t) ((*ltdcptr)>>0x11)&0x7F;
          lmd_tdc_brd = (Int_t) ((*ltdcptr)>>0x1B)&0x1F;
          if(lmd_tdc_brd == 17)
   	    lmd_tdc_slt = 1;
	  else if(lmd_tdc_brd == 18)
	    lmd_tdc_slt = 3;
	  else if(lmd_tdc_brd == 19)
	    lmd_tdc_slt = 4;
	  else if(lmd_tdc_brd == 20)
	    lmd_tdc_slt = 6;

	  /*
          cout << "lmd_tdc_cnt[" << i << "] = " << lmd_tdc_cnt << endl;
          cout << "lmd_tdc_chn[" << i << "] = " << lmd_tdc_chn << endl; 
          cout << "lmd_tdc_brd[" << i << "] = " << lmd_tdc_brd << endl; 
          cout << "lmd_tdc_slt[" << i << "] = " << lmd_tdc_slt << endl;
	  */

          Int_t tdcdch1 = 0;
          Int_t tdcwir1 = 0;
          Int_t rflag1  = -1;
          if(fndfeemap->IsThere()) {

            tdcdch1 = fndfeemap->GetLmdTdcDch(lmd_tdc_slt,lmd_tdc_chn);
            tdcwir1 = fndfeemap->GetLmdTdcWire(lmd_tdc_slt,lmd_tdc_chn);
            rflag1 = fndfeemap->GetLmdTdcSide(lmd_tdc_slt,lmd_tdc_chn); 
	    /*
            cout << "tdcdch1 = " << tdcdch1 << endl;
            cout << "tdcwir1 = " << tdcwir1 << endl;
            cout << "rflag1  = " << rflag1  << endl;
	    */          
            Int_t hit_found = 0;
            n_lmd_hit = fev->GetNHLmd();
            //cout << "n_lmd_hit = " << n_lmd_hit << endl;
            for(Int_t j=0;j<n_lmd_hit;j++) {
              TFndHLmd *htdc = fev->GetHLmd(j);
              Int_t tdcdch = htdc->GetCham();
              Int_t tdcwir = htdc->GetWire();
              if(tdcdch1 != 0 && tdcwir1 != 0 && tdcdch1 == tdcdch && tdcwir1 == tdcwir){
                //cout << "Dch" << tdcdch1 << ", wire " << tdcwir1 << ", flag " << rflag1 << endl;
                hit_found = 1;
                if(rflag1 == 1)
                  htdc->SetTdcF(lmd_tdc_cnt);
                else if(rflag1 == 0)
                  htdc->SetTdcR(lmd_tdc_cnt);
                break;
                }
              }
            if(hit_found == 0 && tdcdch1 != 0 && tdcwir1 != 0) {

//  CREAZIONE DELL' HIT          
              Int_t Tflag = 0;                   
              TFndHLmd *hit;
              if(rflag1 == 0)
                Tflag = 4;
              else if(rflag1 == 1)
                Tflag = 3;
              //cout << "Dch" << tdcdch1 << ", wire " << tdcwir1 << ", flag " << rflag1 << endl;
              hit = new TFndHLmd(tdcdch1,tdcwir1,lmd_tdc_cnt,Tflag);    
              fev->AddHit(hit);
              n_lmd_hit++;
              //hit->Print();
              }
            }
          }
        }
      }
    return n_lmd_hit;
} 
//******************************************************************/
//*                     Build  Stb  Hits  Tree                     */
//******************************************************************/

 void TFndRdt::StbTree(TFndHdt* fev, TFndFeeMap* fndfeemap) {

//*--------> stb hit <----------*/

   Int_t n_stb_hit=0;
   TFndHStb *hit;
   UInt_t *ltdcptr = 0;
   UInt_t ltdclen = 0;

   TFndRawEqp *stbptr = this->GetStb();
   ltdcptr = stbptr->GetEqp(7);
   //   cout << "stb tdc equipment: " << endl;
   //stbptr->PrtEqp(7);
   ltdclen = stbptr->GetEqpLen(7);
   //cout << "stb tdc buffer length: " << ltdclen << endl;

   if(ltdclen) {
      Int_t stb_tdc_cnt;
      Int_t stb_tdc_chn; 
      Int_t stb_tdc_brd;
      Int_t i=0;
      while(i < (Int_t) ltdclen-1) {
        if(i>0) { ltdcptr++; i++; }
        Int_t n_conv = (*ltdcptr)&0xFFFFFF;
        Int_t n_cage = ((*ltdcptr)>>0x18)&0xF;
        //cout << "number of conversions: " << n_conv << endl;
        //cout << "cage number: " << n_cage << endl;
        for(Int_t k=0;k<n_conv;k++) {
	  i++;
          ltdcptr++;
          stb_tdc_cnt = (Int_t) (*ltdcptr)&0xFFFF;
          stb_tdc_chn = (Int_t) ((*ltdcptr)>>0x11)&0x7F;
          stb_tdc_brd = (Int_t) ((*ltdcptr)>>0x1B)&0x1F;
	  /*
	  cout << "stb_tdc_cnt[" << i << "] = " << stb_tdc_cnt << " ";
          cout << "stb_tdc_chn[" << i << "] = " << stb_tdc_chn << " "; 
          cout << "stb_tdc_brd[" << i << "] = " << stb_tdc_brd << endl; 
	  */
	  if(stb_tdc_brd < 6 || stb_tdc_brd > 21) cout << "WARNING: board   # " << stb_tdc_brd << endl; 
	  if(stb_tdc_chn < 0 || stb_tdc_chn > 95) cout << "WARNING: channel # " << stb_tdc_chn << endl;
 
//*--------> map stb tdc channel to stb wire <----------*/

          Int_t tdcwir = 0;
          Int_t ppanel = 0;
          if(fndfeemap->IsThere()) {
            tdcwir = fndfeemap->GetStbWire(n_cage,stb_tdc_brd,stb_tdc_chn);
            ppanel = fndfeemap->GetStbPatchPanel(n_cage,stb_tdc_brd,stb_tdc_chn);
            }
          if(tdcwir == 0)  {
	    cout << "WARNING: Stb wire = 0; cage: " << n_cage << ", board: " << stb_tdc_brd << ", channel: " << stb_tdc_chn << ", content: " << stb_tdc_cnt << endl;
            }

//*--------> add stb hit <----------*/

          Int_t crown = tdcwir/1000;
          Int_t tube = tdcwir-crown*1000;
	  if(crown < 1 || crown > 6) cout << "WARNING: crown # " << crown << endl;
	  if(tube < 1 || tube > 404) cout << "WARNING: tube  # " << tube << endl;
          hit = new TFndHStb(crown,tube,ppanel,stb_tdc_cnt);
          fev->AddHit(hit);
          n_stb_hit++;
          //hit->Print();
          }
        }
   } 
}

 void TFndRdt::Dump() {

   cout << "Header" << endl;
   phdr->Print();
   cout << "Trigger" << endl;
   if(pgts) pgts->Dump();
   cout << "Time of Flight" << endl;
   if(ptof) ptof->Dump();
   cout << "Inner Silicon" << endl;
   if(pism) pism->Dump();
   cout << "Outer Silicon" << endl;
   if(posm) posm->Dump();
   cout << "Drift Chambers" << endl;
   if(plmd) plmd->Dump();
   cout << "Straw Tubes" << endl;
   if(pstb) pstb->Dump();
}