FarPlaneCheckout.cxx

Go to the documentation of this file.

#include <cstdio>
#include "FarPlaneCheckout.h"
// ROOT includes
#include "TCanvas.h"
#include "TDirectory.h"
#include "TF1.h"
#include "TFile.h"
// MINOS includes
#include "Conventions/StripEnd.h"
#include "MessageService/MsgService.h"     // MSG text output
#include "MinosObjectMap/MomNavigator.h"   // Data access
#include "RawData/RawDigit.h"
#include "JobControl/JobCommand.h"         // JobCommand handling
#include "JobControl/JobCModuleRegistry.h" // JOBMODULE registration macro
#include "Plex/PlexHandle.h"
#include "RawData/RawChannelId.h"
#include "RawData/RawChargeInjectInfoBlock.h"
#include "RawData/RawDaqHeader.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawRecord.h"
#include "RawData/RawDaqHeaderBlock.h"
#include "RawData/RawDigitDataBlock.h"
#include "RawData/RawDigit.h"
#include "RawData/RawVarcErrorInTfBlock.h"
#include "RawData/RawLIAdcSummaryBlock.h"
#include "RawData/RawLITimingSummaryBlock.h"
#include "OnlineUtil/mdBlockDefinitions.h"
#include "Validity/VldContext.h"

CVSID("$Id: FarPlaneCheckout.cxx,v 1.5 2003/01/20 10:13:58 west Exp $");
JOBMODULE(FarPlaneCheckout,"FarPlaneCheckout","Plane Checkout procedure for Far Detector\n");

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

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

FarPlaneCheckout::FarPlaneCheckout() 
{
  fFile = 0;
  fRunType = -1;

  for (int icrate=0; icrate<50; icrate++) {
    for (int icharge=0; icharge<128; icharge++) {
      CIbegframe[icrate][icharge] = -1;
      CIendframe[icrate][icharge] = -1;
    }
  }
}


JobCResult FarPlaneCheckout::Ana(const MomNavigator *mom) {



  RawRecord *rawrec = dynamic_cast<RawRecord *>
                                        (mom->GetFragment("RawRecord"));
  if (!rawrec) { 
    MSG("FarPlaneCheckout", Msg::kWarning) << "No RawRecord in MOM." << endl; 
    return JobCResult::kFailed;
  }


  const RawDaqHeader* rhead =
        dynamic_cast<const RawDaqHeader*>(rawrec->GetRawHeader());

  if (!rhead) {
    MSG("FarPlaneCheckout", Msg::kWarning) << "No RawDaqHeader in MOM." << endl; 
    return JobCResult::kFailed;
  }

  if (!fFile) {
    char filename[80];
    sprintf(filename,"planecheckout.%08d.root",rhead->GetRun());
    fFile = new TFile(filename,"RECREATE");

    fth1record = new TH1F("record","record",10000,0.,10000.);

    fFile->mkdir("ADC_bin1");
    fFile->mkdir("ADC_coincidence");
    TDirectory *dirCI = fFile->mkdir("CI");
    dirCI->mkdir("raw");
    fFile->cd();
    fth1adcarray = new TObjArray();
    ftprofCIarray = new TObjArray();
  }


  const TObjArray blocklist(rawrec->GetRawBlockList());
  for (int iblock=0; iblock<=blocklist.GetLast(); iblock++) {
    RawDataBlock *rawdatablock = dynamic_cast<RawDataBlock*>(blocklist.At(iblock));
    if (rawdatablock->GetBlockId().GetMajor()==kMdBlockChargeInjectInfo) {
      const RawChargeInjectInfoBlock *CIBlock = 
        dynamic_cast<const RawChargeInjectInfoBlock*>(rawdatablock);
      if (CIBlock->GetCrateId()>=0 && CIBlock->GetCrateId()<50) {
        for (int icharge=0; icharge<CIBlock->GetNumberOfValues(); icharge++) {
          if (CIBlock->GetCharge(icharge)>=0 && CIBlock->GetCharge(icharge)<128) {
            CIbegframe[CIBlock->GetCrateId()][CIBlock->GetCharge(icharge)] = CIBlock->GetTrigFrameStart(icharge);
            CIendframe[CIBlock->GetCrateId()][CIBlock->GetCharge(icharge)] = CIBlock->GetTrigFrameEnd(icharge);
          }
        }
      }
      cout << "blockid " << CIBlock->GetBlockId().GetMajor() << " " << CIBlock->GetBlockId().GetMinor() << " " << CIBlock->GetBlockId().IsDCS() << " " << CIBlock->GetBlockId().GetDetector() << "\n";
      for (int icharge=0; icharge<CIBlock->GetNumberOfValues() && CIBlock->GetCharge(icharge)>=0; icharge++) {
        cout << "charge " << icharge << "/" << CIBlock->GetNumberOfValues() << " " << CIBlock->GetCrateId() << " " << CIBlock->GetTrigFrameStart(icharge) << " " << CIBlock->GetTrigFrameEnd(icharge) << " " << CIBlock->GetCharge(icharge) << "\n";
      }

    }
  }


  int timeframeno=-1;
  const RawSnarlHeaderBlock* rawsnarlHdrBlock = 
     dynamic_cast<const RawSnarlHeaderBlock*>
     (rawrec->FindRawBlock("RawSnarlHeaderBlock"));
  if (rawsnarlHdrBlock) {
    timeframeno = rawsnarlHdrBlock->GetTimeFrameNo();
  }
  const RawDaqSnarlHeader* snarlHdr = 
     dynamic_cast<const RawDaqSnarlHeader*>(rawrec->GetRawHeader());
  if (snarlHdr) {
     fth1record->Fill((float)snarlHdr->GetSnarl());
     //nt_record = snarlHdr->GetSnarl();
     //nt_error = snarlHdr->GetErrorCode();
  }
  const RawDaqHeaderBlock* rawdaqHdrBlock = 
     dynamic_cast<const RawDaqHeaderBlock*>
     (rawrec->FindRawBlock("RawDaqHeaderBlock"));
  if (rawdaqHdrBlock) {
//     nt_time = rawdaqHdrBlock->GetTimeStamp().GetSec();
//     nt_time = rawdaqHdrBlock->GetTimeFrameNo();
    timeframeno = rawdaqHdrBlock->GetTimeFrameNo();
  }
  const RawVarcErrorInTfBlock* rawVarcErrorBlock = 
     dynamic_cast<const RawVarcErrorInTfBlock*>
     (rawrec->FindRawBlock("RawVarcErrorInTfBlock"));
  if (rawVarcErrorBlock) {
    //const Int_t *sparserr = rawVarcErrorBlock->GetSparsErrorValues();
    //const Int_t *etcerr = rawVarcErrorBlock->GetEtcErrorValues();
    //nt_varcerr_crate = rawVarcErrorBlock->GetCrateId();
    //nt_varcerr_tf = rawVarcErrorBlock->GetTimeFrame();
    //nt_varcerr_nspars = rawVarcErrorBlock->GetNumberOfSparsErrors();
    //nt_varcerr_netc = rawVarcErrorBlock->GetNumberOfEtcErrors();
    for (int i=0; i<rawVarcErrorBlock->GetNumberOfSparsErrors(); i++) {
      //nt_varcerr_word = sparserr[i];
      //fVarcErrorNt->Fill();
    }
    for (int i=0; i<rawVarcErrorBlock->GetNumberOfEtcErrors(); i++) {
      //nt_varcerr_word = etcerr[i];
      //fVarcErrorNt->Fill();
    }
  }
  RawRecord *rr = dynamic_cast<RawRecord *>
                                        (mom->GetFragment("RawRecord"));
  if (rr == 0) {
    MSG("FarPlaneCheckout", Msg::kWarning) << "No RawRecord in MOM." << endl;
    return JobCResult::kFailed;
  }


  PlexHandle *plexhandle = new PlexHandle(rhead->GetVldContext());


  fRunType = rhead->GetRunType();

  if (snarlHdr) {

// pedestal and normal data
    if (rhead->GetRunType()==1 || rhead->GetRunType()==2) {
  
      TIter rdbit = rr->GetRawBlockIter();
      TObject *tob;
      while ((tob = rdbit())) {
        if (tob->InheritsFrom("RawDigitDataBlock")) {
          RawDigitDataBlock *rdb = (RawDigitDataBlock *) tob;
          TIter rdit = rdb->GetDatumIter();
          RawDigit *rd;
          rd = (RawDigit *)rdit();
          while (rd) {
            if (rd) {
              RawChannelId rawch = rd->GetChannel();
              if (TH1F *th1adc = frawid2th1adc[rawch]) {
                th1adc->Fill((Float_t)rd->GetADC());
              }
              else {
                char histtitle[256];
                sprintf(histtitle,"ADC %02d %01d %01d %01d %01d %02d",rawch.GetCrate(),rawch.GetVarcId(),rawch.GetVmm(),rawch.GetVaAdcSel(),rawch.GetVaChip(),rawch.GetVaChannel());
                fFile->cd("/ADC_bin1");
                frawid2th1adc[rawch] = new TH1F(histtitle,histtitle,2000,-500.,1500.);
                fth1adcarray->Add(frawid2th1adc[rawch]);
                frawid2th1adc[rawch]->Fill((Float_t)rd->GetADC());
              }
            }
            rd = (RawDigit *)rdit();
          }
        }
      }
    }
  
  
// normal data, null trigger
    if (rhead->GetRunType()==2 && (snarlHdr->GetTrigSrc())&(0x1)) {
  
  
      TIter rdbit = rr->GetRawBlockIter();
      TObject *tob;
      while ((tob = rdbit())) {
        if (tob->InheritsFrom("RawDigitDataBlock")) {
          RawDigitDataBlock *rdb = (RawDigitDataBlock *) tob;
          TIter rdit0 = rdb->GetDatumIter();
          TIter rdit1 = rdb->GetDatumIter();
          RawDigit *rd0;
          RawDigit *rd1;
          rd1 = (RawDigit *)rdit1();
          RawChannelId rawid1 = rd1->GetChannel();
          while (rd1 && rawid1.GetCrate()==0) {
            rd1 = (RawDigit *)rdit1();
            if (rd1) {
              rawid1 = rd1->GetChannel();
            }
          }
          rd0 = (RawDigit *)rdit0();
          RawChannelId rawid0 = rd0->GetChannel();
          TObjArray sortedlist;
          while (rd0 || rd1) {
            if (rd0 && !rd1) {
              sortedlist.Add(rd0);
              rd0 = (RawDigit *)rdit0();
              RawChannelId rawid0 = rd0->GetChannel();
              if (rawid0.GetCrate()==1) rd0=0;
            }
            else if (rd1 && !rd0) {
              sortedlist.Add(rd1);
              rd1 = (RawDigit *)rdit1();
            }
            else if (rd0 && rd1) {
              if (rd0->GetTDC()<rd1->GetTDC()) {
                sortedlist.Add(rd0);
                rd0 = (RawDigit *)rdit0();
                RawChannelId rawid0 = rd0->GetChannel();
                if (rawid0.GetCrate()==1) rd0=0;
              } else {
                sortedlist.Add(rd1);
                rd1 = (RawDigit *)rdit1();
              }
            }
          }
          RawDigit *rd;
          TObjArray timewindow;
          for (int isort=0; isort<=sortedlist.GetLast(); isort++) {
            rd = (RawDigit *)(sortedlist.At(isort));
            RawChannelId rawid = rd->GetChannel();
            if (plexhandle->GetReadoutType(rawid) == ReadoutType::kScintStrip) {
              PlexSEIdAltL altlist = plexhandle->GetSEIdAltL(rawid);
              for (int isort1=isort-1; isort1>=0; isort1--) {
                RawDigit *rd1 = (RawDigit *)(sortedlist.At(isort1));
                RawChannelId rawid1 = rd1->GetChannel();
                if (rd->GetTDC()-rd1->GetTDC()>100) {
                  isort1 = -1;
                } else if (plexhandle->GetReadoutType(rawid1) == ReadoutType::kScintStrip){
                  PlexSEIdAltL altlist1 = plexhandle->GetSEIdAltL(rawid1);
                  altlist.SetFirst();
                  while (altlist.IsValid()) {
                    PlexStripEndId stripend = altlist.GetCurrentSEId();
                    altlist1.SetFirst();
                    while (altlist1.IsValid()) {
                      PlexStripEndId stripend1 = altlist1.GetCurrentSEId();
                      if (stripend.IsOppositeStripEnd(stripend1)) {
                        Int_t stripindex = stripend.GetPlane()*192+stripend.GetStrip();
                        if (TH1F *th1strip = fstrip2th1adc[stripindex]) {
                          th1strip->Fill((Float_t)(rd->GetADC()+rd1->GetADC()));
                        }
                        else {
                          char histtitle[256];
                          sprintf(histtitle,"ADC Plane %03d Strip %03d",stripend.GetPlane(),stripend.GetStrip());
                          fFile->cd("/ADC_coincidence");
                          fstrip2th1adc[stripindex] = new TH1F(histtitle,histtitle,3000,0.,3000.);
                          fstrip2th1adc[stripindex]->Fill((Float_t)(rd->GetADC()+rd1->GetADC()));
                        }
                      }
                      altlist1.Next();
                    }
                    altlist.Next();
                  }
                }
              }
            }
          }
        }
      }
  
    }
  
  
// charge injection
    if (rhead->GetRunType()==3) {
  
// this needs to be fixed once charge inject info blocks can be read in
      //unused: int chargein = (int)((snarlHdr->GetSnarl()-3)/2)*10;
  
      TIter rdbit = rr->GetRawBlockIter();
      TObject *tob;
      while ((tob = rdbit())) {
        if (tob->InheritsFrom("RawDigitDataBlock")) {
          RawDigitDataBlock *rdb = (RawDigitDataBlock *) tob;
          TIter rdit = rdb->GetDatumIter();
          RawDigit *rd;
          rd = (RawDigit *)rdit();
          while (rd) {
            if (rd) {
              RawChannelId rawch = rd->GetChannel();
              if (TProfile *tprofCI = frawid2tprofCIraw[rawch]) {
//                tprofCI->Fill((Float_t)chargein,(Float_t)rd->GetADC());
                tprofCI->Fill((Float_t)timeframeno,(Float_t)rd->GetADC());
              }
              else {
                char histtitle[256];
                sprintf(histtitle,"%02d %01d %01d %01d %01d %02d",rawch.GetCrate(),rawch.GetVarcId(),rawch.GetVmm(),rawch.GetVaAdcSel(),rawch.GetVaChip(),rawch.GetVaChannel());
                fFile->cd("/CI/raw");
// assume charge injection doesn't go for more than one hour
                frawid2tprofCIraw[rawch] = new TProfile(histtitle,histtitle,3600,0.,3600.);
                ftprofCIarray->Add(frawid2tprofCIraw[rawch]);
//                frawid2tprofCIraw[rawch]->Fill((Float_t)chargein,(Float_t)rd->GetADC());
                frawid2tprofCIraw[rawch]->Fill((Float_t)timeframeno,(Float_t)rd->GetADC());
              }
            }
            rd = (RawDigit *)rdit();
          }
        }
      }
  
    }
  
// normal data, light injection trigger
    if (rhead->GetRunType()==2 && (snarlHdr->GetTrigSrc())&(0x2)) {
  
  
      TIter rdbit = rr->GetRawBlockIter();
      TObject *tob;
      while ((tob = rdbit())) {
        if (tob->InheritsFrom("RawDigitDataBlock")) {
          RawDigitDataBlock *rdb = (RawDigitDataBlock *) tob;
          TIter rdit = rdb->GetDatumIter();
          RawDigit *rd;
          rd = (RawDigit *)rdit();
          while (rd) {
            RawChannelId rawid = rd->GetChannel();
            rd = (RawDigit *)rdit();
          }
        }
      }
    }
  
  
  }


  const RawLIAdcSummaryBlock *rawLIadcblock = 
    dynamic_cast<const RawLIAdcSummaryBlock*>
    (rawrec->FindRawBlock("RawLIAdcSummaryBlock"));

  const RawLITimingSummaryBlock *rawLItimingblock = 
    dynamic_cast<const RawLITimingSummaryBlock*>
    (rawrec->FindRawBlock("RawLITimingSummaryBlock"));

  if (rawLIadcblock) {
    rawLIadcblock->Print();
  }

  if (rawLItimingblock) {
    rawLItimingblock->Print();
  }

  delete plexhandle;

  return JobCResult::kPassed;

}


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

void FarPlaneCheckout::HandleCommand(JobCommand* cmd)
{
//======================================================================
// Handle a command send from the job controller
// 
// Inputs: cmd - The parsed job command
//======================================================================
  if (cmd->HaveCmd()) {                      // If we have a command...
    string sc = cmd->PopCmd();               // Get the command
    MSG("FarPlaneCheckout",Msg::kWarning) << "Don't understand '" << sc.c_str() << "'\n";
  }
}


void FarPlaneCheckout::EndJob() 
{
//======================================================================
// At the end of the job print some stuff out and save the histogram
// to a file
//======================================================================

// fit gaussian if pedestal run

  if (fRunType==1 && fth1adcarray) {
    for (Int_t ith1 = 0; ith1<=fth1adcarray->GetLast(); ith1++) {
      TH1F *th1 = dynamic_cast<TH1F*>(fth1adcarray->At(ith1));
      th1->Fit("gaus","q");
    }
  }

  if (fRunType==3 && ftprofCIarray) {
    TF1 linfit("linfit","pol1",0.,60.);
    int ibinoff = {3}; // offset since bins start at zero
    for (Int_t itprof = 0; itprof<=ftprofCIarray->GetLast(); itprof++) {
      TProfile *tprofraw = dynamic_cast<TProfile*>(ftprofCIarray->At(itprof));
      fFile->cd("/CI");
      TProfile *tprof = new TProfile(tprofraw->GetName(),tprofraw->GetTitle(),128,0.,128.);
      int icrate,ivarc,ivmm,ivaadc,ivachip,ivachannel;
      sscanf(tprofraw->GetTitle(),"%02d %01d %01d %01d %01d %02d",&icrate,&ivarc,&ivmm,&ivaadc,&ivachip,&ivachannel);
      
      if (icrate>=0 && icrate<50) {
        for (int icharge=0; icharge<128; icharge++) {
          if (CIbegframe[icrate][icharge]>=0 && 
              CIbegframe[icrate][icharge]<=CIendframe[icrate][icharge]) {
            double xavg=0.;
            double navg=0.;
            //unused: double xerr=0.;
            //unused: double xgerr=0.;
            for (int ibin=CIbegframe[icrate][icharge]+ibinoff; ibin<=CIendframe[icrate][icharge]+ibinoff; ibin++) {
/*
              if (tprofraw->GetBinError(ibin)>1e-4) {
                xerr += 1./(tprofraw->GetBinError(ibin)*tprofraw->GetBinError(ibin));
              }
*/
              navg += tprofraw->GetBinEntries(ibin);
              xavg += tprofraw->GetBinEntries(ibin)*tprofraw->GetBinContent(ibin);
            }
            if (navg>0.) {
              xavg /= navg;
            }
            tprof->Fill((float)icharge,(float)xavg,1.);
          }
        }
        tprof->Fit("linfit","qr");
      }
    }
  }


  if (fFile) {
    fFile->Write();
    fFile->Close();
  }

}

---