DetLatency.cc

Go to the documentation of this file.

#include "DetLatency.h"
#include "Event/Readout.h"
#include "Event/CalibReadout.h"
#include "Event/CalibReadoutPmtCrate.h"
#include "Event/CalibReadoutPmtChannel.h"
#include "Event/RunData.h"
#include "DataSvc/ICableSvc.h"
#include "DataSvc/ICalibDataSvc.h"
#include "Event/RawEventHeader.h"
#include <math.h>
#include <fstream>
#include "TMath.h"

#include "Event/RegistrationSequence.h"
#include "Event/CalibReadoutHeader.h"
#include "Event/CalibReadoutPmtCrate.h"
#include "Event/ReadoutHeader.h"
#include "Event/ReadoutPmtCrate.h"
#include "Event/RawEventHeader.h"
#include "Event/GenHeader.h"
#include "HepMC/GenEvent.h"
#include "HepMC/GenVertex.h"
#include "Event/RecHeader.h"
#include "Event/TagHeader.h"
#include "DataUtilities/DybArchiveList.h"
#include "GaudiKernel/SmartDataPtr.h"

DetLatency::DetLatency(const std::string& name, ISvcLocator* pSvcLocator):
  GaudiAlgorithm(name, pSvcLocator)
{
  declareProperty("FileName", m_fileName = "AdcFit.root", "Root file name");
  declareProperty("FitPeriod", m_fitPeriod = 30*60, "Fit period in second, Default is 30 minutes");
  declareProperty("Fix", m_Fix = 0, "a temp fix for 40M noise");
  declareProperty("Offset",  m_Trig_Interval_Offset_ns=1000, "Muon trigger time calculate range for latency in ns");

  m_NTrigger=0;
  m_NStop = 1;
  m_startrun = -1;
  m_currentrun = -1;
  m_execNum=0;  
}


DetLatency::~DetLatency()
{
}


void DetLatency::Fit(){

  //cout<<"Fitting"<<endl;
  ostringstream tmp;
  tmp <<setw(2) <<setfill('0') << m_NStop;
  string filename = "trigLatencyTable_"+tmp.str()+".txt";
  FILE* outfile = fopen(filename.c_str(), "w+");
  
  fprintf(outfile, "# First Trigger time: (TrigSecond, TrigNanoSec) = (%d,%d).\n", m_FirstTrigSecond, m_FirstTrigNanoSec);
  fprintf(outfile, "# Last Trigger time: (TrigSecond, TrigNanoSec) = (%d,%d).\n", m_LastTrigSecond, m_LastTrigNanoSec);
  fprintf(outfile, "# [detId] [description] [status] [trigLat] [trigLatErr] [trigLatSigma] [trigLatSigmaErr]\n");

  m_rootfile->cd();
  string newdir = tmp.str();
  m_rootfile->mkdir(newdir.c_str());
  m_rootfile->cd(newdir.c_str());

  m_masterfile = fopen("Master.trigLatencyCalibMap.txt", "a");
  TimeStamp lastT1(m_LastTrigSecond,m_LastTrigNanoSec+1);
  fprintf(m_masterfile, "0000000 0000000 %4.0d %4.0d %10.0d %10.0d %10.0d %10.0d %s\n",
          m_site, m_simFlag, m_FirstTrigSecond,m_FirstTrigNanoSec,(int)lastT1.GetSec(),lastT1.GetNanoSec(),filename.c_str());
  fclose(m_masterfile);

  m_StartTime = m_FirstTrigSecond + m_FirstTrigNanoSec*1e-9;
  m_EndTime = m_LastTrigSecond + m_LastTrigNanoSec*1e-9;
  
  //cout<<"Test 0"<<endl;


      double pedarea=0;
      double pedmean=0;
      double pedsigm=0;
      int status1=0;
     int tester=0;
  //cout<<"Test 1"<<endl;
  //cout<<"h_TrigT_AD1->GetEntries()="<<h_TrigT_AD1->GetEntries()<<endl;
  if(h_TrigT_AD1->GetEntries()>0)
  {    
      pedarea = h_TrigT_AD1->GetEntries();
      pedmean = h_TrigT_AD1->GetMean();
      pedsigm = h_TrigT_AD1->GetRMS();
      f1->SetParameters(pedarea,pedmean,pedsigm);
      f1->SetRange(pedmean-3*pedsigm,pedmean+3*pedsigm);
      status1 = h_TrigT_AD1->Fit("f1","R");
      

      trigLatencyAD1Status=status1;
       trigLatencyAD1= f1->GetParameter(1);
      trigLatencyAD1Err= f1->GetParError(1);
      trigLatencyAD1Sigma = f1->GetParameter(2);
      trigLatencyAD1SigmaErr= f1->GetParError(2);

      //cout<<"1"<<tester++<<endl;
     fprintf(outfile, "%d %s %2d %8.3f %8.3f %8.3f %8.3f\n",DetectorId::kAD1, DetectorId::AsString(DetectorId::kAD1),trigLatencyAD1Status, trigLatencyAD1, trigLatencyAD1Err, trigLatencyAD1Sigma, trigLatencyAD1SigmaErr);

      //cout<<"2"<<tester++<<endl;   

      h_TrigT_AD1->Write();
      //cout<<"3"<<tester++<<endl;
      h_CalibTrigT->Fill(trigLatencyAD1);
      //cout<<"4"<<tester++<<endl;
      h_CalibTrigTErr->Fill(trigLatencyAD1Err);
      //cout<<"5"<<tester++<<endl;
      //cout<<"trigLatencyAD1Sigma="<<trigLatencyAD1Sigma<<endl;
      h_CalibTrigTSigma->Fill(trigLatencyAD1Sigma);
      //cout<<"6"<<tester++<<endl;
      h_CalibTrigTSigmaErr->Fill(trigLatencyAD1SigmaErr);
      //cout<<"7"<<tester++<<endl;
  }
  //cout<<"h_TrigT_AD2->GetEntries()="<<h_TrigT_AD2->GetEntries()<<endl;
  if(h_TrigT_AD2->GetEntries()>0)
  {
      pedarea = h_TrigT_AD2->GetEntries();
      pedmean = h_TrigT_AD2->GetMean();
      pedsigm = h_TrigT_AD2->GetRMS();
      f2->SetParameters(pedarea,pedmean,pedsigm);
      f2->SetRange(pedmean-3*pedsigm,pedmean+3*pedsigm);
      status1 = h_TrigT_AD2->Fit("f2","R");

      trigLatencyAD2Status=status1;
      h_TrigT_All->Fill(trigLatencyAD1);
      trigLatencyAD2= f2->GetParameter(1);
      trigLatencyAD2Err= f2->GetParError(1);
      trigLatencyAD2Sigma = f2->GetParameter(2);
      trigLatencyAD2SigmaErr= f2->GetParError(2);

      fprintf(outfile, "%d %s %2d %8.3f %8.3f %8.3f %8.3f\n", DetectorId::kAD2, DetectorId::AsString(DetectorId::kAD2), trigLatencyAD2Status, trigLatencyAD2, trigLatencyAD2Err, trigLatencyAD2Sigma, trigLatencyAD2SigmaErr);
      
      h_TrigT_AD2->Write();
      h_TrigT_All->Fill(trigLatencyAD2);
      h_CalibTrigT->Fill(trigLatencyAD2);
      h_CalibTrigTErr->Fill(trigLatencyAD2Err);
      h_CalibTrigTSigma->Fill(trigLatencyAD2Sigma);
      h_CalibTrigTSigmaErr->Fill(trigLatencyAD2SigmaErr);
  }
  
    //cout<<"h_TrigT_AD3->GetEntries()="<<h_TrigT_AD3->GetEntries()<<endl;
  if(h_TrigT_AD3->GetEntries()>0)
  {
      pedarea = h_TrigT_AD3->GetEntries();
      pedmean = h_TrigT_AD3->GetMean();
      pedsigm = h_TrigT_AD3->GetRMS();
      f3->SetParameters(pedarea,pedmean,pedsigm);
      f3->SetRange(pedmean-3*pedsigm,pedmean+3*pedsigm);
      status1 = h_TrigT_AD3->Fit("f3","R");

      trigLatencyAD3Status=status1;
       trigLatencyAD3= f3->GetParameter(1);
      trigLatencyAD3Err= f3->GetParError(1);
      trigLatencyAD3Sigma = f3->GetParameter(2);
      trigLatencyAD3SigmaErr= f3->GetParError(2);
      fprintf(outfile, "%d %s %2d %8.3f %8.3f %8.3f %8.3f\n", DetectorId::kAD3, DetectorId::AsString(DetectorId::kAD3),trigLatencyAD3Status, trigLatencyAD3, trigLatencyAD3Err, trigLatencyAD3Sigma, trigLatencyAD3SigmaErr);

      h_TrigT_AD3->Write();
      h_TrigT_All->Fill(trigLatencyAD3);
      h_CalibTrigT->Fill(trigLatencyAD3);
      h_CalibTrigTErr->Fill(trigLatencyAD3Err);
      h_CalibTrigTSigma->Fill(trigLatencyAD3Sigma);
      h_CalibTrigTSigmaErr->Fill(trigLatencyAD3SigmaErr);
  }
  if(h_TrigT_AD4->GetEntries()>0)
  {
      pedarea = h_TrigT_AD4->GetEntries();
      pedmean = h_TrigT_AD4->GetMean();
      pedsigm = h_TrigT_AD4->GetRMS();
      f4->SetParameters(pedarea,pedmean,pedsigm);
      f4->SetRange(pedmean-3*pedsigm,pedmean+3*pedsigm);
      status1 = h_TrigT_AD4->Fit("f4","R");

      trigLatencyAD4Status=status1;
       trigLatencyAD4= f4->GetParameter(1);
      trigLatencyAD4Err= f4->GetParError(1);
      trigLatencyAD4Sigma = f4->GetParameter(2);
      trigLatencyAD4SigmaErr= f4->GetParError(2);
      fprintf(outfile, "%d %s %2d %8.3f %8.3f %8.3f %8.3f\n", DetectorId::kAD4, DetectorId::AsString(DetectorId::kAD4),trigLatencyAD4Status, trigLatencyAD4, trigLatencyAD4Err, trigLatencyAD4Sigma, trigLatencyAD4SigmaErr);

      h_TrigT_AD4->Write();
      h_TrigT_All->Fill(trigLatencyAD4);
      h_CalibTrigT->Fill(trigLatencyAD4);
      h_CalibTrigTErr->Fill(trigLatencyAD4Err);
      h_CalibTrigTSigma->Fill(trigLatencyAD4Sigma);
      h_CalibTrigTSigmaErr->Fill(trigLatencyAD4SigmaErr);
  }
    //cout<<"h_TrigT_IWS->GetEntries()="<<h_TrigT_IWS->GetEntries()<<endl;
  if(h_TrigT_IWS->GetEntries()>0)
  {
      pedarea = h_TrigT_IWS->GetEntries();
      pedmean = h_TrigT_IWS->GetMean();
      pedsigm = h_TrigT_IWS->GetRMS();
      f5->SetParameters(pedarea,pedmean,pedsigm);
      f5->SetRange(pedmean-3*pedsigm,pedmean+3*pedsigm);
      status1 = h_TrigT_IWS->Fit("f5","R");

      trigLatencyIWSStatus=status1;
       trigLatencyIWS= f5->GetParameter(1);
      trigLatencyIWSErr= f5->GetParError(1);
      trigLatencyIWSSigma = f5->GetParameter(2);
      trigLatencyIWSSigmaErr= f5->GetParError(2);
      fprintf(outfile, "%d %s %2d %8.3f %8.3f %8.3f %8.3f\n", DetectorId::kIWS, DetectorId::AsString(DetectorId::kIWS), trigLatencyIWSStatus, trigLatencyIWS, trigLatencyIWSErr, trigLatencyIWSSigma, trigLatencyIWSSigmaErr);

      h_TrigT_IWS->Write();
      h_TrigT_All->Fill(trigLatencyIWS);
      h_CalibTrigT->Fill(trigLatencyIWS);
      h_CalibTrigTErr->Fill(trigLatencyIWSErr);
      h_CalibTrigTSigma->Fill(trigLatencyIWSSigma);
      h_CalibTrigTSigmaErr->Fill(trigLatencyIWSSigmaErr);
  }

 // //cout<<"h_TrigT_OWS->GetEntries()="<<h_TrigT_OWS->GetEntries()<<endl;
  if(h_TrigT_OWS->GetEntries()>0)
  {
      pedarea = h_TrigT_OWS->GetEntries();
      pedmean = h_TrigT_OWS->GetMean();
      pedsigm = h_TrigT_OWS->GetRMS();
      f6->SetParameters(pedarea,pedmean,pedsigm);
      f6->SetRange(pedmean-3*pedsigm,pedmean+3*pedsigm);
      status1 = h_TrigT_OWS->Fit("f6","R");

      trigLatencyOWSStatus=status1;
       trigLatencyOWS= f6->GetParameter(1);
      trigLatencyOWSErr= f6->GetParError(1);
      trigLatencyOWSSigma = f6->GetParameter(2);
      trigLatencyOWSSigmaErr= f6->GetParError(2);
      fprintf(outfile, "%d %s %2d %8.3f %8.3f %8.3f %8.3f\n", DetectorId::kOWS, DetectorId::AsString(DetectorId::kOWS), trigLatencyOWSStatus, trigLatencyOWS, trigLatencyOWSErr, trigLatencyOWSSigma, trigLatencyOWSSigmaErr);

      h_TrigT_OWS->Write();
      h_TrigT_All->Fill(trigLatencyOWS);
      h_CalibTrigT->Fill(trigLatencyOWS);
      h_CalibTrigTErr->Fill(trigLatencyOWSErr);
      h_CalibTrigTSigma->Fill(trigLatencyOWSSigma);
      h_CalibTrigTSigmaErr->Fill(trigLatencyOWSSigmaErr);
  }
  if(h_TrigT_RPC->GetEntries()>0)
  {
      pedarea = h_TrigT_RPC->GetEntries();
      pedmean = h_TrigT_RPC->GetMean();
      pedsigm = h_TrigT_RPC->GetRMS();
      f7->SetParameters(pedarea,pedmean,pedsigm);
      f7->SetRange(pedmean-3*pedsigm,pedmean+3*pedsigm);
      status1 = h_TrigT_RPC->Fit("f7","R");

      trigLatencyRPCStatus=status1;
       trigLatencyRPC= f7->GetParameter(1);
      trigLatencyRPCErr= f7->GetParError(1);
      trigLatencyRPCSigma = f7->GetParameter(2);
      trigLatencyRPCSigmaErr= f7->GetParError(2);
      fprintf(outfile, "%d %s %2d %8.3f %8.3f %8.3f %8.3f\n", DetectorId::kRPC, DetectorId::AsString(DetectorId::kRPC), trigLatencyRPCStatus, trigLatencyRPC, trigLatencyRPCErr, trigLatencyRPCSigma, trigLatencyRPCSigmaErr);

      h_TrigT_RPC->Write();
      h_TrigT_All->Fill(trigLatencyRPC);
      h_CalibTrigT->Fill(trigLatencyRPC);
      h_CalibTrigTErr->Fill(trigLatencyRPCErr);
      h_CalibTrigTSigma->Fill(trigLatencyRPCSigma);
      h_CalibTrigTSigmaErr->Fill(trigLatencyRPCSigmaErr);
  }


   //cout<<"fitting finished"<<endl;
  //m_tree->Fill();
  fclose(outfile);
}

int DetLatency::InitPmtProp(const ServiceMode& svc)
{

  string hname = "h_TrigT_AD1";
  h_TrigT_AD1=new TH1F(hname.c_str(),hname.c_str(),2000,-1000,1000);

  hname = "h_TrigT_AD2";
  h_TrigT_AD2=new TH1F(hname.c_str(),hname.c_str(),2000,-1000,1000);
 
  hname = "h_TrigT_AD3";
  h_TrigT_AD3=new TH1F(hname.c_str(),hname.c_str(),2000,-1000,1000);

  hname = "h_TrigT_AD4";
  h_TrigT_AD4=new TH1F(hname.c_str(),hname.c_str(),2000,-1000,1000);

  hname = "h_TrigT_IWS";
  h_TrigT_IWS=new TH1F(hname.c_str(),hname.c_str(),2000,-1000,1000);

  hname = "h_TrigT_OWS";
  h_TrigT_OWS=new TH1F(hname.c_str(),hname.c_str(),2000,-1000,1000);

  hname = "h_TrigT_RPC";
  h_TrigT_RPC=new TH1F(hname.c_str(),hname.c_str(),2000,-1000,1000);

  hname = "h_TrigT_All";
  h_TrigT_All=new TH1F(hname.c_str(),hname.c_str(),8000,-400,400);

  hname = "h_CalibTrigT";
  h_CalibTrigT=new TH1F(hname.c_str(),hname.c_str(),8000,-400,400);

  hname = "h_CalibTrigTErr";
  h_CalibTrigTErr=new TH1F(hname.c_str(),hname.c_str(),8000,-400,400);

  hname = "h_CalibTrigTSigma";
  h_CalibTrigTSigma=new TH1F(hname.c_str(),hname.c_str(),8000,-400,400);

  hname = "h_CalibTrigTSigmaErr";
  h_CalibTrigTSigmaErr=new TH1F(hname.c_str(),hname.c_str(),8000,-400,400);


  //map<int,PmtProp>::iterator it,idend=m_PmtPropMap.end(); //pmtID
  //for(it=m_PmtPropMap.begin(); it!=idend; it++) {
  //  PmtProp& curr = it->second;
  //}
  
  ResetPmtProp();//reset

  m_NStop = 1;
  m_startrun = -1;
  m_currentrun = -1;
  m_execNum=0;  
  m_NTrigger=0;

  return 1;
}

int DetLatency::ResetPmtProp()
{
  h_TrigT_AD1->Reset();
  h_TrigT_AD2->Reset();
  h_TrigT_AD3->Reset();
    h_TrigT_AD4->Reset();
  h_TrigT_IWS->Reset();
    h_TrigT_OWS->Reset();
    h_TrigT_RPC->Reset();


  m_NTrigger = 0;
  m_startrun = -1;

  m_execNum=0;
  return 1;
}

StatusCode DetLatency::initialize()
{

  StatusCode sc;
  sc = this->GaudiAlgorithm::initialize();
  if( sc.isFailure() ) {
    error() << "Base class initialization error" << endreq;
    return sc;
  }

  sc = service("RunDataSvc",m_runDataSvc);
  if( sc.isFailure() ) {
    error() << "Can't get RunDataSvc" << endreq;
    return sc;
  }

  sc = service("CableSvc",m_cableSvc);
  if( sc.isFailure() ) {
    error() << "Can't get CableSvc" << endreq;
    return sc;
  }

  StatusCode status = service("EventDataArchiveSvc", p_archiveSvc);
  if (status.isFailure()) {
    Error("Service [EventDataArchiveSvc] not found", status);
  }

  f1 = new TF1("f1","gaus",-500,500);
  f2 = new TF1("f2","gaus",-500,500);

  f3 = new TF1("f3","gaus",-500,500);
  f4 = new TF1("f4","gaus",-500,500);
  f5 = new TF1("f5","gaus",-500,500);
  f6 = new TF1("f6","gaus",-500,500);
  f7 = new TF1("f7","gaus",-500,500);
  m_rootfile = new TFile(m_fileName.c_str(),"recreate");
  //m_tree = new TTree("t", "My Tree");
  //m_tree->SetMaxTreeSize(200000000);  // 200M

  m_masterfile = fopen("Master.trigLatencyCalibMap.txt", "a");
  fprintf(m_masterfile, "# [StartRun] [EndRun] [Sites] [SimFlag] [StartTimeSec] [StartTimeNanoSec] [EndTimeSec] [EndTimeNanoSec] [map file]\n");
  fclose(m_masterfile);

  return sc;

  return 1;
}

StatusCode DetLatency::execute()
{
  debug()<<"DetLatency executing ... "<<endreq;

  StatusCode sc;
  
  //RawEventHeader* reh = get<RawEventHeader>(RawEventHeader::defaultLocation());
  //if(!reh) {
  //  warning()<<"Failed to get raw event header"<<endreq;
  //}

  ReadoutHeader* readoutHdr = get<ReadoutHeader>( ReadoutHeader::defaultLocation() );
  if(!readoutHdr) {
    error()<<"Failed to get readout header"<<endreq;
    return StatusCode::FAILURE;
  }
  const DaqCrate* daqCrate = readoutHdr->daqCrate();
  if(!daqCrate) {
    error()<<"Failed to get daqCrate from header"<<endreq;
    return StatusCode::FAILURE;
  }

  TimeStamp trigTime = daqCrate->triggerTime();
  m_currentTime = trigTime.GetSec();

  static bool first = true;
  if( first ) {
    first = false;
    Context ctx = readoutHdr->context();
    m_site=ctx.GetSite();
    m_simFlag=ctx.GetSimFlag();
    ctx.SetSite(Site::kAll);
    ctx.SetDetId(DetectorId::kAll);
    ServiceMode svc(ctx,0);
    //
    InitPmtProp(svc);
    //
    m_prevTrigTime = trigTime.GetSec();
    m_lastFitTime = trigTime.GetSec();
  }

  if((daqCrate->detector().isAD()))
  {
    const DaqPmtCrate* pmtCrate = daqCrate->asPmtCrate();
    if (!pmtCrate) {
      error()<<"Failed to get DaqPmtCrate"<<endreq;
    return StatusCode::SUCCESS;
    }
    Detector det = pmtCrate->detector();
  }
  ServiceMode svcMode( readoutHdr->context(),0 );

  m_NTrigger++;
  // Keep tracking the first trigger time and 
  // the laster trigger for this group of fit
  m_LastTrigSecond = trigTime.GetSec();
  m_LastTrigNanoSec = trigTime.GetNanoSec();
 //m_LastTrigSecond= readoutHdr->timeStamp().GetSec();
  //m_LastTrigNanoSec= readoutHdr->timeStamp().GetNanoSec();

  if(m_NTrigger==1){
    m_FirstTrigSecond = trigTime.GetSec();
    m_FirstTrigNanoSec = trigTime.GetNanoSec();
  }


    bool Range_exceed_flag=false;
    double trig_interval=0;
     int AES_counter=0;
    TimeStamp tagTimeStamp;
    TimeStamp trigTime2;
    TimeStamp tagTimeStamp_begin;
    //SmartDataPtr<DybArchiveList>  muonlist(p_archiveSvc,"/Event/Tag/Muon/MuonAll");
    SmartDataPtr<DybArchiveList>  muonlist(p_archiveSvc,"/Event/Readout/ReadoutHeader");
    if(muonlist) {
      //info() << "Number of muon in the ArchiveList: " << muonlist->size() << endreq;
    DybArchiveList::const_iterator iter = muonlist->begin();
    HeaderObject* muonAll_begin=dynamic_cast<HeaderObject*>(*iter);
    vector<const IHeader*> ihs_begin = muonAll_begin->inputHeaders();
    IHeader* iHeader_begin = const_cast<IHeader*>(ihs_begin[0]);
    HeaderObject* header_begin = dynamic_cast<HeaderObject*>(iHeader_begin);
      tagTimeStamp_begin=header_begin->timeStamp();
     // //cout<<"muonlist->size()="<<muonlist->size()<<endl;
      bool Valid_flag = false;
      for(; iter != muonlist->end(); iter++){
      AES_counter++;
      HeaderObject* muonAll = dynamic_cast<HeaderObject*>(*iter);
      vector<const IHeader*> ihs = muonAll->inputHeaders();
      
       // //cout<<"header size="<<ihs.size()<<endl;
        int i;
       for(i = 0; i < ihs.size(); i++) {
          IHeader* iHeader = const_cast<IHeader*>(ihs[i]);
          HeaderObject* header = dynamic_cast<HeaderObject*>(iHeader);
          int loopDet = header->context().GetDetId();
          //string SiteName = Site::AsString(detector.site());
          //string DetName  = DetectorId::AsString(detector.detectorId());
          //if(daqCrate->detector().isAD())
          if(loopDet==DetectorId::kAD1)// all the time is related to AD1
          //if(DetName=="AD1")
          {
             tagTimeStamp = header->timeStamp();
            trig_interval=(tagTimeStamp_begin.GetSec()-tagTimeStamp.GetSec())*1000000000+(tagTimeStamp_begin.GetNanoSec()-tagTimeStamp.GetNanoSec());
              if(abs(trig_interval)>=m_Trig_Interval_Offset_ns)
              {
                  m_tagTimeStamp=tagTimeStamp;
                  if((m_tagTimeStamp.GetSec()-m_tagTimeStamp_last.GetSec())*1000000000+(m_tagTimeStamp.GetNanoSec()-m_tagTimeStamp_last.GetNanoSec())>0)
                  {
                     m_tagTimeStamp_last=tagTimeStamp;
                    Valid_flag=true;
                    m_execNum++;
                  }
                  else
                  {
                    Range_exceed_flag=true;
                    break;
                  }
               }
              if(Valid_flag)
                  break;
              if(Range_exceed_flag)
                  break;
            }
          }//for(unsigned int i = 0; i < ihs.size(); i++)
          if(Valid_flag)
            break;
          if(Range_exceed_flag)
            break;
      }//end of Muonlist at 1st time
      
      if(Valid_flag)
      {
      Range_exceed_flag=false;
      //DybArchiveList::const_iterator iter = muonlist->begin();
      DybArchiveList::const_iterator iter2 = muonlist->begin();
        AES_counter=0;
      for(; iter2 != muonlist->end(); iter2++){
      AES_counter++;
      HeaderObject* muonAll2 = dynamic_cast<HeaderObject*>(*iter2);
      vector<const IHeader*> ihs2 = muonAll2->inputHeaders();
      for(unsigned int i = 0; i < ihs2.size(); i++) {
          IHeader* iHeader2 = const_cast<IHeader*>(ihs2[i]);
          HeaderObject* header2 = dynamic_cast<HeaderObject*>(iHeader2);
          int loopDet = header2->context().GetDetId();

          trigTime2 =header2->timeStamp();
          //if(AES_counter==1)
          //{
           // //cout<<"begin="<<trigTime2.GetNanoSec()<<endl;
          //}
          trig_interval=(trigTime2.GetSec()-m_tagTimeStamp.GetSec())*1000000000+(trigTime2.GetNanoSec()-m_tagTimeStamp.GetNanoSec());
          if(abs(trig_interval)<=m_Trig_Interval_Offset_ns)
          {
          if(loopDet==DetectorId::kAD1)
          {
          
          // //cout<<"trig_interval="<<trig_interval<<endl;
            h_TrigT_AD1->Fill(trig_interval);
          }         
          if(loopDet==DetectorId::kAD2)
          {
            h_TrigT_AD2->Fill(trig_interval);
          }
          if(loopDet==DetectorId::kAD3)
          {
            h_TrigT_AD3->Fill(trig_interval);
          }
          if(loopDet==DetectorId::kAD4)
          {
            h_TrigT_AD4->Fill(trig_interval);
          }
          if(loopDet==DetectorId::kIWS)
          {
           // //cout<<"kIWS"<<endl;
                 // //cout<<"IWS find ="<<trigTime2.GetNanoSec()<<" zero="<<m_tagTimeStamp.GetNanoSec()<<"  trig_interval="<<trig_interval<<endl;
            h_TrigT_IWS->Fill(trig_interval);
          }
          if(loopDet==DetectorId::kOWS)
          {
           // //cout<<"kOWS"<<endl;
            h_TrigT_OWS->Fill(trig_interval);
          }
          if(loopDet==DetectorId::kRPC)
          {
            h_TrigT_RPC->Fill(trig_interval);
          }
          }
          else if(trig_interval<-1*m_Trig_Interval_Offset_ns)
          {
            Range_exceed_flag=true;
            break;
           }
      }//for(unsigned int i = 0; i < ihs.size(); i++)
        if(Range_exceed_flag)
          break;
     }// for(; iter != muonlist->end(); iter++)
   // //cout<<endl;
    }//if true
    }//end of if(muonlist)

  //  //cout << "run number:" << m_runDataSvc->runData(svcMode)->runNumber() << endl;
  
  //int TrigType = pmtCrate->triggerType();
  //if( TrigType != 7 ) {


  //-------------------------------------
  //fit the data
  if(m_currentTime - m_lastFitTime > m_fitPeriod) {
    //Fit
    Fit();
    //after fit
    ResetPmtProp();
    m_NStop++;
    m_lastFitTime = m_currentTime;
  }
  
  m_prevTrigTime = m_currentTime;


  return StatusCode::SUCCESS;
}

StatusCode DetLatency::finalize()
{
  //cout<<"DetLatency finalize...."<<endl;

  //Fit
  Fit();

      h_TrigT_All->Write();
      h_CalibTrigT->Write();
      h_CalibTrigTErr->Write();
      h_CalibTrigTSigma->Write();
      h_CalibTrigTSigmaErr->Write();

  m_rootfile->Write();
  m_rootfile->Close();


  delete f1;
  delete f2;
  delete f3;
  delete f4;
  delete f5;
  delete f6;
  delete f7;
  //delete m_tree;
  delete m_rootfile;

 // //cout<<"Test 3"<<endl;

  if (0 != p_archiveSvc) {
    p_archiveSvc->release();
  }

  delete h_TrigT_AD1;
   delete  h_TrigT_AD2;
  delete   h_TrigT_AD3;
  delete   h_TrigT_AD4;
  delete   h_TrigT_IWS;
    delete h_TrigT_OWS;
    delete h_TrigT_RPC;


 // //cout<<"Test 5"<<endl;

       delete h_TrigT_All;
       delete h_CalibTrigT;
       delete h_CalibTrigTErr;
       delete h_CalibTrigTSigma;
        delete h_CalibTrigTSigmaErr;


 //cout<<"Finished"<<endl;


  StatusCode sc;
  sc = this->GaudiAlgorithm::finalize();
  return sc;

  return 1;
}