DetectorAlignmentModule.cxx

Go to the documentation of this file.

//
//
// DetectorAlignmentModule
//
// Package: DetectorAlignment
//
// JobModule for accessing DetectorAlignment
//
// Contact: rustem@fnal.gov
//
// Created on: Fri Sep 24 15:26:05 2004
//

//DetectorAlignment classes
#include "DetectorAlignmentModule.h"
#include "DetectorAlignment.h"
#include "NtpAlignmentRecord.h"

//MINOS
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "CandData/CandRecord.h"
#include "RawData/RawRecord.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RecoBase/CandStripListHandle.h"
#include "CandTrackSR/CandTrackSRHandle.h"
#include "CandTrackSR/CandTrackSRListHandle.h"
#include "JobControl/JobCModuleRegistry.h"

//C++
#include <iostream>
#include <cassert>

JOBMODULE(DetectorAlignmentModule,"DetectorAlignment","Aligns detector using straight tracks");

CVSID("$Id: DetectorAlignmentModule.cxx,v 1.5 2005/07/30 21:25:31 rustem Exp $");

DetectorAlignmentModule::DetectorAlignmentModule()
   : fAlign(0),
     fNRecords(0),
     fNProcessedRecords(0),
     fNSkippedRecords(0),
     fNAlignmentTracks(0),
     fNMultipleTracks(0)
{
   MSG("Align", Msg::kInfo) << "Constructor DetectorAlignmentModule()" << endl;
   fAlign = new DetectorAlignment();
}

void DetectorAlignmentModule::BeginJob()
{      
   MSG("Align", Msg::kInfo) << "DetectorAlignmentModule::BeginJob()" << endl;
   fTimer.Start();
}

JobCResult DetectorAlignmentModule::Reco(MomNavigator* mom)
{
   assert(mom);
   fNRecords++;

   RawRecord *raw_record=0;
   CandRecord *cand_record=0;
   int n_raw_record=0, n_cand_record=0;

   TIter mit(mom -> FragmentIter());
   TObject *fragment_obj;
   while( (fragment_obj = mit()) ) 
   {
      raw_record  = dynamic_cast<RawRecord *> (fragment_obj);
      cand_record = dynamic_cast<CandRecord *> (fragment_obj);
      if(raw_record) n_raw_record++;
      if(cand_record) n_cand_record++;
   }

   if(n_raw_record != 1 && n_cand_record != 1)
   {
      MSG("Align", Msg::kWarning) << "Multiple entries for RawRecord or CandRecord!" << endl;
      return JobCResult::kAOK;
   }
   
   const RawDaqSnarlHeader *rawhdr = dynamic_cast<const RawDaqSnarlHeader *>(raw_record->GetRawHeader());
   if(!rawhdr) 
   {
      MSG("Align", Msg::kError) << "Missing required raw data header." << endl;
      return JobCResult::kAOK;
   }

   CandTrackSRListHandle *tklh=0;
   CandStripListHandle *cslh=0;
   int n_track_lists=0, n_strip_lists=0;

   TIter cit(cand_record -> GetCandHandleIter());
   TObject *cand_obj;
   while( (cand_obj = mit()) ) 
   {
      tklh = dynamic_cast<CandTrackSRListHandle *> (cand_obj);
      cslh = dynamic_cast<CandStripListHandle *> (cand_obj);
      if(tklh) n_track_lists++;
      if(cslh) n_strip_lists++;
   }

   if(n_track_lists != 1 && n_strip_lists != 1)
   {
      MSG("Align", Msg::kWarning) << "Multiple entries for track or strip lists." << endl;
      return JobCResult::kAOK;
   }


   if(tklh->GetNDaughters() != 1)
   {
      fNMultipleTracks++;
      MSG("Align", Msg::kDebug)<< "There are "<< tklh -> GetNDaughters() << " tracks." << endl;
      return JobCResult::kAOK;  
   }      

   TIter itr(tklh -> GetDaughterIterator());
   while( CandTrackSRHandle* trkh = dynamic_cast<CandTrackSRHandle *>(itr()) )
   {
      MSG("Align", Msg::kDebug) << "Found alignment track"<< endl;
      
      fNAlignmentTracks++;
      RecCandHeader ntphdr(rawhdr -> GetVldContext(),
                           rawhdr -> GetRun(),
                           rawhdr -> GetSubRun(),
                           rawhdr -> GetRunType(),
                           rawhdr -> GetErrorCode(),
                           rawhdr -> GetSnarl(),
                           rawhdr -> GetTrigSrc(),
                           rawhdr -> GetTimeFrameNum(),
                           rawhdr -> GetRemoteSpillType(),
                           fNAlignmentTracks);
      
      NtpAlignmentRecord* ntpalignrec = new NtpAlignmentRecord(ntphdr);   
      
      //Main alignment algorithm
      const bool result =  fAlign -> RunAlignment(trkh, cslh, ntpalignrec);
      
      if(result)
         mom -> AdoptFragment(ntpalignrec);
      else 
      {
         delete ntpalignrec;
         MSG("Align",Msg::kDebug) << "Snarl "<<fNRecords<<" false result!"<<endl;
         fNSkippedRecords++;
      }
   }

   if(fNRecords % 1000 == 0)
      MSG("Align", Msg::kInfo) << "DetectorAlignmentModule snarl #" << fNRecords << endl;
   else 
      MSG("Align",Msg::kDebug) << "DetectorAlignmentModule snarl #" << fNRecords << endl; 

   fNProcessedRecords++;
   return JobCResult::kAOK;
}

void DetectorAlignmentModule::EndJob()
{

   MSG("Align", Msg::kInfo) << "DetectorAlignmentModule: EndJob()" << endl
                            << "Number of processed snarls: " << fNRecords << endl
                            << "Number of alignment tracks: " << fNAlignmentTracks << endl
                            << "Number of proccesed records: " << fNProcessedRecords << endl
                            << "Number of skipped records: " << fNSkippedRecords << endl
                            << "Number of multiple tracks records: " << fNMultipleTracks << endl 
                            << "Cpu time:  " << fTimer.CpuTime() << endl
                            << "Real time: " << fTimer.RealTime() << endl;

   if(fAlign){
      delete fAlign;
      fAlign = 0;
   }
}
   

DetectorAlignmentModule::~DetectorAlignmentModule()
{
   MSG("Align", Msg::kInfo) << "Destructor ~DetectorAlignmentModule()" << endl;
   if(fAlign)
   {
      delete fAlign;
      fAlign = 0;
   }
}

---