LISummaryModule.cxx

Go to the documentation of this file.

// Program name: LISummaryModule.cxx  
//                                                                     
// Package: LISummary
//  
// Coded by Jeff Hartnell Oct/2002-Feb/2004   
//                                                                  
// Based on code by: Rob Morse Feb/2002   
//                                                                    
// Purpose: A module to collect raw LI summaries or pulser summaries 
//          from the data stream
//                                                                    
// Contact: jeffrey.hartnell@physics.ox.ac.uk   

#include <iostream>
#include <map>

#include "TDatime.h"
#include "TFile.h"
#include "TH1.h"
#include "TH2.h"
#include "TProfile.h"
#include "TROOT.h"

#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCommand.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "PulserCalibration/PulserSummaryList.h"
#include "PulserCalibration/PulserFromRawSummaryList.h"
#include "PulserCalibration/PulserSummary.h"
#include "RawData/RawLIAdcSummary.h"
#include "RawData/RawDaqHeader.h"
#include "RawData/RawLIAdcSummaryBlock.h"
#include "RawData/RawRunCommentBlock.h"
#include "RawData/RawLIHeader.h" 

#include "LISummary/LISummaryModule.h"

#include <cassert>

JOBMODULE(LISummaryModule,"LISummaryModule","A module to collect raw LI summary blocks or pulser summaries from the data stream");

CVSID("$Id: LISummaryModule.cxx,v 1.5 2007/11/11 08:00:53 rhatcher Exp $");

ClassImp(LISummaryModule)

//......................................................................

LISummaryModule::LISummaryModule() 
{
  MSG("LISummaryModule", Msg::kDebug) 
   <<"Running LISummaryModule constructor..."<<endl;

  //initialise data members
  calibPoint=-1;
  calibType=-1;
  fDataReconstructed=false;
  led=-1;
  fLedLast=-1;
  //don't need these two below, it is set in DefaultConfig
  //fLIRunSeqReq=1;//set to first run seq in long run by default
  //fWriteOnlyGainCurves=0;
  mean=-1;
  numEntries=-1;
  period=-1;
  pulseHeight=-1;
  pulserBox=-1;
  pulses=-1;
  pulseWidth=-1;
  rms=-1;
  timeNanoSec=-1; 
  timeSec=-1;

  MSG("LISummaryModule", Msg::kDebug) 
   <<"Finished constructor"<<endl;
}

//......................................................................

LISummaryModule::~LISummaryModule()
{
  MSG("LISummaryModule", Msg::kDebug) 
   <<"Running destructor..."<<endl;

  MSG("LISummaryModule", Msg::kDebug) 
   <<"Finished destructor"<<endl;
}

//......................................................................

JobCResult LISummaryModule::Reco(MomNavigator *mom)
{
  JobCResult result(JobCResult::kPassed);

  //check that mom exists.
  assert(mom);
  
  //find raw record in mom
  RawRecord *rawrec = dynamic_cast<RawRecord *>
    (mom->GetFragment("RawRecord"));
  
  if (!rawrec) {
    result.SetError().SetFailed();
    MSG("LISummaryModule",Msg::kError) 
      <<"No raw record in mom"<<endl;
    return result;
  }

  //get raw header
  const RawDaqHeader *rawDaqHdr=
     dynamic_cast<const RawDaqHeader*>(rawrec->GetRawHeader());
  if (rawDaqHdr){
    summarySorter.SetRunNumber(rawDaqHdr->GetRun());
    summarySorter.SetRunNumberSub(rawDaqHdr->GetSubRun());
    summarySorter.SetRunType(rawDaqHdr->GetRunType());
    summarySorter.SetDetector(rawDaqHdr->GetVldContext());
    VldContext v=rawDaqHdr->GetVldContext();
    summarySorter.SetRawDaqVldCtx(v);
    MSG("LISummaryModule", Msg::kVerbose) 
      <<"Time in raw daq header is: "<<v.GetTimeStamp()<<endl;
  }

  Bool_t fUseSummaryBlocks=true;
  Bool_t fUsePulserBlocks=false;

  if (fUseSummaryBlocks){
    result=GetSummaryBlocks(rawrec);
    return result;
  }
  else if (fUsePulserBlocks){
    result=GetPulserBlocks(rawrec,mom);
    return result;
  }
  else{
    result.SetError().SetFailed();
    MSG("LISummaryModule",Msg::kError) 
      <<"Summary or Pulser Block not specified"<<endl;
    return result;
  }
}

//......................................................................

JobCResult LISummaryModule::GetPulserBlocks(RawRecord* rawrec,
                                               MomNavigator *mom)
{
  JobCResult result(JobCResult::kPassed);

  PulserFromRawSummaryList *psl = dynamic_cast
    <PulserFromRawSummaryList *>
    (mom->GetFragment("PulserFromRawSummaryList"));
  
  if (!psl) {
    MSG("LISummaryModule",Msg::kInfo) 
      <<"No pulser summary list here\n";
    return JobCResult::kFailed;
  }

  MSG("LISummaryModule",Msg::kInfo) 
    <<"Got pulser summary "<<psl->GetPointIndex()
    <<" of "<<psl->GetExpectedPoints()<<endl;

  //TIter itr = rawRec->GetRawBlockIter();
  //RawDataBlock* rawBlk;

  const RawRunCommentBlock* rrcb=dynamic_cast<const RawRunCommentBlock*>
    (rawrec->FindRawBlock("RawRunCommentBlock"));
  //<RawRunCommentBlock*>(rawBlk)

  //get LI Summary block from rawdatablock
  //  const RawLIAdcSummaryBlock *rawliadcsummaryblock = 
  // dynamic_cast<const RawLIAdcSummaryBlock*>
  //(rawrec->FindRawBlock("RawLIAdcSummaryBlock"));


  if(rrcb){
    //look at rawrunconfig block too
    MSG("LISummaryModule",Msg::kInfo) 
      << "------------------------------------------------" << endl
      << "COMMENT:" << endl
      << rrcb->GetRunComment() << endl
      << "------------------------------------------------" << endl;
  }
  else {
    MSG("LISummaryModule",Msg::kInfo) 
      <<"No raw run comment block in mom"<<endl;
  }

  VldContext vDaqHdr;
  //get raw header
  const RawDaqHeader *rawDaqHdr=
     dynamic_cast<const RawDaqHeader*>(rawrec->GetRawHeader());
  if (rawDaqHdr){
    summarySorter.SetRunNumber(rawDaqHdr->GetRun());
    summarySorter.SetRunNumberSub(rawDaqHdr->GetSubRun());
    summarySorter.SetRunType(rawDaqHdr->GetRunType());
    summarySorter.SetDetector(rawDaqHdr->GetVldContext());
    vDaqHdr=rawDaqHdr->GetVldContext();
    MSG("LISummaryModule", Msg::kVerbose) 
      <<"Time in raw daq header is: "<<vDaqHdr.GetTimeStamp()<<endl;
  }

  // Work through psl..  
  timeStamp=vDaqHdr.GetTimeStamp();
  timeSec=timeStamp.GetSec();
  timeNanoSec=timeStamp.GetNanoSec();
  calibPoint=psl->GetPointIndex();
  calibType=psl->GetExpectedPoints();
  pulserBox=psl->GetPulserBox();
  led=psl->GetLed();
  pulseHeight=psl->GetHeight();
  pulseWidth=psl->GetWidth();
  pulses=psl->GetNumPulses();
  period=10;//psl->GetPeriod();
    
  //set the plex handle with the current vld context
  summarySorter.SetPlexHandle(psl->GetVldContext());
  summarySorter.Update(led,pulseHeight,pulseWidth,pulserBox,calibPoint,
                       timeStamp,calibType,pulses,period);
  
  map<Int_t,PulserSummary>::const_iterator ps=psl->GetNearBegin();

  while (ps!=psl->GetNearEnd()){
    
    mean=(*ps).second.GetMean();
    rms=(*ps).second.GetRMS();
    numEntries=(*ps).second.GetEntries();
    
    UInt_t rawchannel=(*ps).second.GetChannel();

    summarySorter.AddEntry(rawchannel,mean,rms,numEntries);  
    //  cout<<(*ps).second.GetChannel().GetCrate()<<endl;
    ps++;
  }
  
  //summarySorter.CountNumSummaries(rawliadcsummaryblock->
  //                      GetNumberOfSummaries());

  //Work through all summaries
  //for(Int_t n=0;n<rawliadcsummaryblock->GetNumberOfSummaries();n++){
  //const RawLIAdcSummary *rawliadcsummary=
  //  rawliadcsummaryblock->At(n);
      
  //mean=rawliadcsummary->GetMean();
  //rms=rawliadcsummary->GetRms();
  //numEntries=rawliadcsummary->GetEntries();
      
  //summarySorter.AddEntry(rawliadcsummary->GetChannel(),
  //               mean,rms,numEntries);  
  //}

  return result;
}

//......................................................................

JobCResult LISummaryModule::GetSummaryBlocks(RawRecord* rawrec)
{
  JobCResult result(JobCResult::kPassed);

  //get LI Summary block from rawdatablock
  const RawLIAdcSummaryBlock *rawliadcsummaryblock = 
    dynamic_cast<const RawLIAdcSummaryBlock*>
    (rawrec->FindRawBlock("RawLIAdcSummaryBlock"));
  
  //check li block exists
  if(!rawliadcsummaryblock){  
    result.SetError().SetFailed();
    MSG("LISummaryModule",Msg::kError) 
      <<"No Raw LI Adc Summary Block in raw record"<<endl;
    return result;
  }
  
  //Work through rawliadcsummaryblock
  timeStamp=rawliadcsummaryblock->GetTimeStamp();
  timeSec=timeStamp.GetSec();
  timeNanoSec=timeStamp.GetNanoSec();
  calibPoint=rawliadcsummaryblock->GetCalibPoint();
  calibType=rawliadcsummaryblock->GetCalibType();
  pulserBox=rawliadcsummaryblock->GetPulserBox();
  led=rawliadcsummaryblock->GetLed();
  pulseHeight=rawliadcsummaryblock->GetPulseHeight();
  pulseWidth=rawliadcsummaryblock->GetPulseWidth();
  pulses=rawliadcsummaryblock->GetPulses();
  period=rawliadcsummaryblock->GetPeriod();

  //print out the current TF summary block info
  if (MsgService::Instance()->IsActive("LISummaryModule",
                                       Msg::kDebug)){
    this->PrintBlockInfo("LICollector: New Block ");
  }


  //Section to control which DPs (or GCs) are written to file

  //check if only GCs are requested
  if (fWriteOnlyGainCurves){
    MAXMSG("LISummaryModule",Msg::kInfo,1)
      <<"Only points with calibType>1 (i.e. GCs) will be written out"<<endl; 
    if (calibType==1){//then it's a drift point and you want to strip it out

      //only print out info if it's a new ledIndex
      Int_t ledIndex=pulserBox*fLookup.NUMLEDS+led;
      static Int_t lastLedIndex=-1;
      if (ledIndex!=lastLedIndex){
        MSG("LISummaryModule",Msg::kInfo) 
          <<"Only writing GCs, skipping drift point with settings:"<<endl;
        //print out the point that was rejected 
        //(before set to new values)
        this->PrintBlockInfo("  ");
      }
      lastLedIndex=ledIndex;
      return JobCResult::kFailed;
    }
    else{
      //just carry on
    }
  }
  else {
    MAXMSG("LISummaryModule",Msg::kInfo,1)
      <<"All calibTypes will be written out"<<endl; 
  }
  
  if (led>=fLookup.FIRSTLED && led<=fLookup.LASTLED && 
      pulserBox>=fLookup.FIRSTPULSERBOX &&
      pulserBox<=fLookup.LASTPULSERBOX){
    //add the ledIndex to the counter
    //but only if it's a new ledIndex (have to allow gain curves!)
    Int_t ledIndex=pulserBox*fLookup.NUMLEDS+led;
    static Int_t lastLedIndex=-1;//only assigned -1 on first call
    MSG("LISummaryModule",Msg::kVerbose) 
      <<"lastLedIndex="<<lastLedIndex<<endl;
    if (ledIndex!=lastLedIndex){
      fLIRunSeqCurrent[ledIndex]++;//this is a map so isn't ledIndex-1
    }
    
    //check which DP in a long run we want to write to the tree
    //if fLIRunSeqReq=-1 then write out everything
    if (fLIRunSeqCurrent[ledIndex]!=fLIRunSeqReq && fLIRunSeqReq!=-1){
      
      //only print out info if it's a new ledIndex
      if (ledIndex!=lastLedIndex){
        MSG("LISummaryModule",Msg::kInfo) 
          <<endl
          <<" ** Skipping point in this run, fLIRunSeqReq="
          <<fLIRunSeqReq
          <<", fLIRunSeqCurrent["<<ledIndex<<"]="
          <<fLIRunSeqCurrent[ledIndex]<<" **"
          <<endl;    
        //print out the point that was rejected 
        //(before set to new values)
        this->PrintBlockInfo("Point had settings: ");
      }
      lastLedIndex=ledIndex;
      
      return JobCResult::kFailed;
    }
    lastLedIndex=ledIndex;
  }
  else{
    static Int_t numberMsg=0;
    if (numberMsg<10){
      MSG("LISummaryModule",Msg::kWarning) 
        <<endl<<"Skipping summary block with strange values:"<<endl;
      this->PrintBlockInfo("");
      if (numberMsg==9){
        MSG("LISummarySorter",Msg::kWarning) 
          <<endl
          <<"This is the last message of this type to be printed"
          <<endl;
      }
    }
    numberMsg++;
    return JobCResult::kFailed;
  }
  //End of section to control which DP are written to file

  static Int_t firstTimeSec=timeSec;
  MAXMSG("LISummaryModule",Msg::kInfo,1)
    <<endl<<"First timestamp to be written out = "<<firstTimeSec<<endl; 
  
  //set the plex handle with the current vld context
  summarySorter.SetPlexHandle(rawliadcsummaryblock->GetVldContext());

  //update the sorter
  summarySorter.Update(led,pulseHeight,pulseWidth,pulserBox,calibPoint,
                       timeStamp,calibType,pulses,period);

  summarySorter.CountNumSummaries(rawliadcsummaryblock->
                                  GetNumberOfSummaries());
  //Work through all summaries
  for(Int_t n=0;n<rawliadcsummaryblock->GetNumberOfSummaries();n++){
    const RawLIAdcSummary *rawliadcsummary=
      rawliadcsummaryblock->At(n);
    
    mean=rawliadcsummary->GetMean();
    rms=rawliadcsummary->GetRms();
    numEntries=rawliadcsummary->GetEntries();
    
    summarySorter.AddEntry(rawliadcsummary->GetChannel(),
                           mean,rms,numEntries);  

    //fill the profiles used for debuging
    static Bool_t fillProfiles=false;
    if (fillProfiles) {
      MAXMSG("LISummaryModule",Msg::kInfo,500)
        <<"entries="<<numEntries<<", mean="<<mean<<", rms="<<rms<<endl;

      MAXMSG("LISummaryModule",Msg::kInfo,1)
        <<endl<<"Creating TProfile to look at entries in each summary"<<endl;
      static TProfile* pSummarySizeVsTF=new TProfile
        ("pSummarySizeVsTF","pSummarySizeVsTF",10000,0,10000);
      static TProfile* pSummarySizeVsTFAll=new TProfile
        ("pSummarySizeVsTFAll","pSummarySizeVsTFAll",10000,0,10000);
      static TProfile* pSummarySizeVsTF90=new TProfile
        ("pSummarySizeVsTF90","pSummarySizeVsTF90",10000,0,10000);
      static TH1F* hSummarySize=new TH1F
        ("hSummarySize","hSummarySize",1000,0,1000);//up to a kHz
      
      static vector<TProfile*> vProf50;
      static vector<TProfile*> vProf90;
      if (vProf50.size()==0){
        cout<<"Creating vector of TProfiles..."<<endl;
        for (Int_t i=0;i<=150;i++){
          string s="pSummaryEntVsTF50Pl";
          s+=Form("%d",i);
          cout<<"Creating TProfile with name="<<s<<endl;
          TProfile* p=new TProfile(s.c_str(),s.c_str(),10000,0,10000);
          vProf50.push_back(p);
          
          s="pSummaryEntVsTF90Pl";
          s+=Form("%d",i);
          cout<<"Creating TProfile with name="<<s<<endl;
          p=new TProfile(s.c_str(),s.c_str(),10000,0,10000);
          vProf90.push_back(p);
        }
      }
      
      PlexHandle ph(rawliadcsummaryblock->GetVldContext());
      Int_t plane=ph.GetSEIdAltL(rawliadcsummary->GetChannel()).GetPlane();
      MAXMSG("LISummaryModule",Msg::kInfo,500)
        <<endl<<"Filling TProfiles, plane="<<plane<<endl;
      if (plane>-1 && plane<150 && numEntries>90) vProf90[plane]->
        Fill(timeSec-firstTimeSec,numEntries);
      if (plane>-1 && plane<150 && numEntries>50) vProf50[plane]->
        Fill(timeSec-firstTimeSec,numEntries);
      
      //only fill if a decent number of entries are found
      if (numEntries>50) pSummarySizeVsTF->Fill(timeSec-firstTimeSec,numEntries);
      if (numEntries>90) pSummarySizeVsTF90->Fill(timeSec-firstTimeSec,numEntries);
      pSummarySizeVsTFAll->Fill(timeSec-firstTimeSec,numEntries);    
      hSummarySize->Fill(numEntries);
    }
  }
  //if control makes it this far then data will have been reconstructed
  fDataReconstructed=true;
  return result;
}

//......................................................................
  
void LISummaryModule::PrintBlockInfo(string preString)
{
  MSG("LISummaryModule",Msg::kVerbose)<<"PrintBlockInfo..."<<endl;

  TDatime datime;
  datime.Set(timeStamp.GetSec());
  
  //play around with the formatting a little
  string sHour=Form("%d",datime.GetHour());
  string sMinute=Form("%d",datime.GetMinute());
  string sSecond=Form("%d",datime.GetSecond());
  string sMonth=Form("%d",datime.GetMonth());
  string sDay=Form("%d",datime.GetDay());
  if (datime.GetHour()<10) sHour="0"+sHour;
  if (datime.GetMinute()<10) sMinute="0"+sMinute;
  if (datime.GetSecond()<10) sSecond="0"+sSecond;
  if (datime.GetMonth()<10) sMonth="0"+sMonth;
  if (datime.GetDay()<10) sDay="0"+sDay;

  //protect from fpe
  Double_t pulseFreq=-1;
  if (period!=0) pulseFreq=ceil(1.0/(period*1.0e-5));
  string sPulseFreq=Form("%d",static_cast<Int_t>(pulseFreq));
  string sPeriod=Form("%d",static_cast<Int_t>(period));
  if (pulseFreq<0) sPulseFreq="??? (period="+sPeriod+")";

  MSG("LISummaryModule",Msg::kInfo) 
    <<preString 
    <<"PB="<<pulserBox 
    <<" Led="<<led
    <<" CP="<<calibPoint
    <<"/"<<calibType
    <<" PH="<<pulseHeight
    <<" PW="<<pulseWidth
    <<" PF="<<sPulseFreq
    <<" PN="<<pulses
    <<" at "<<sHour
    <<":"<<sMinute
    <<":"<<sSecond
    <<" on "<<datime.GetYear()
    <<"/"<<sMonth
    <<"/"<<sDay
    <<endl;

  MSG("LISummaryModule",Msg::kVerbose) 
    <<"PrintBlockInfo method finished"<<endl;
}

//......................................................................

void LISummaryModule::BeginJob() 
{
  MSG("LISummaryModule",Msg::kInfo)
    <<endl
    <<"**********************************************************"<<endl
    <<"This code has a new feature. It can pluck out a particular"<<endl
    <<"LI run, e.g. when there are multiple drift points it only"<<endl
    <<"returns the one defined by fLIRunSeqReq"<<endl
    <<"Setting fLIRunSeqReq to be -1 writes out everything"<<endl
    <<"This variable is set in LIReco.C using LIRunSeqRequired"<<endl
    <<"Currently fLIRunSeqReq="<<fLIRunSeqReq<<endl
    <<"**********************************************************"
    <<endl<<endl;
}

//......................................................................

void LISummaryModule::EndJob() 
{  
  if (fDataReconstructed){

    //write out the profiles if they exist
    TObject* o=gROOT->FindObject("pSummarySizeVsTFAll");
    if (o) o->Write();
    o=gROOT->FindObject("pSummarySizeVsTF90");
    if (o) o->Write();
    o=gROOT->FindObject("pSummarySizeVsTF");
    if (o) o->Write();
    o=gROOT->FindObject("hSummarySize");
    if (o) o->Write();
    
    for (Int_t i=0;i<=150;i++){
      string s="pSummaryEntVsTF50Pl";
      s+=Form("%d",i);
      o=gROOT->FindObject(s.c_str());
      if (o) o->Write();
      //else {MAXMSG("LISummaryModule",Msg::kInfo,10)<<"Can't find object with name="<<s<<endl;}
      s="pSummaryEntVsTF90Pl";
      s+=Form("%d",i);
      o=gROOT->FindObject(s.c_str());
      if (o) o->Write();
      //else {MAXMSG("LISummaryModule",Msg::kInfo,10)<<"Can't find object with name="<<s<<endl;}
    }

    //add 10000 to led to trigger the writing to file of last data  
    //(and to make it obvious!)
    summarySorter.Update(led+10000,pulseHeight,pulseWidth,pulserBox,
                         calibPoint,timeStamp,calibType,pulses,period);
    summarySorter.PrintRecoSummary();
    //this has to be last
    summarySorter.OutputData();
  }
  else {
    //just print what was found (could just be no LI stream!)
    summarySorter.PrintRecoSummary();
  }
}

//......................................................................

const Registry& LISummaryModule::DefaultConfig() const
{

  MSG("LISummaryModule", Msg::kDebug)
    << "Running LISummaryModule::DefaultConfig..." << endl;
    
  static Registry r;

  string name=this->JobCModule::GetName();
  name+=".config.default";
  r.SetName(name.c_str());
  r.UnLockValues();

  r.Set("LIRunSeqRequired",-1);
  r.Set("WriteOnlyGainCurves",0);

  r.LockValues();

  return r;
}

//......................................................................

void LISummaryModule::Config(const Registry &r)
{

  MSG("LISummaryModule", Msg::kDebug)<<"LISummaryModule::Config"<<endl;

  Int_t runSeqReq=-1;
  if (r.Get("LIRunSeqRequired",runSeqReq)) fLIRunSeqReq=runSeqReq;

  Int_t writeOnlyGainCurves=0;
  if (r.Get("WriteOnlyGainCurves",writeOnlyGainCurves)) fWriteOnlyGainCurves=
                                                          writeOnlyGainCurves;
}

//......................................................................

---