AlgFitTrackCamList.cxx

Go to the documentation of this file.

// Package: CandFitTrackCam
//
// AlgFitTrackCamList.cxx
//
// marshall@hep.phy.cam.ac.uk
#include <cassert>
extern "C" {
#include <unistd.h>    // sysconf
#include <sys/times.h> // times()
}

#include "Conventions/Munits.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "Navigation/NavKey.h"
#include "Navigation/NavSet.h"
#include "Validity/VldContext.h"

#include "Algorithm/AlgFactory.h"
#include "Algorithm/AlgHandle.h"
#include "Algorithm/AlgConfig.h"
#include "Candidate/CandContext.h"

#include "RecoBase/CandTrackHandle.h"
#include "RecoBase/CandTrackListHandle.h"
#include "RecoBase/CandStripHandle.h"
#include "RecoBase/CandStripListHandle.h"
#include "RecoBase/CandSliceHandle.h"
#include "RecoBase/CandSliceListHandle.h"
#include "CandDigit/CandDigitHandle.h"

#include "CandFitTrackCam/AlgFitTrackCamList.h"
#include "CandFitTrackCam/CandFitTrackCamListHandle.h"
#include "CandFitTrackCam/CandFitTrackCamHandle.h"

#include "TObjArray.h"

ClassImp(AlgFitTrackCamList)

CVSID("$Id: AlgFitTrackCamList.cxx,v 1.11 2008/07/03 21:55:22 gmieg Exp $");

AlgFitTrackCamList::AlgFitTrackCamList()
{
}


AlgFitTrackCamList::~AlgFitTrackCamList()
{
}


void AlgFitTrackCamList::RunAlg(AlgConfig &ac,CandHandle &ch,CandContext &cx)
{
  assert(cx.GetDataIn());

  // Check for CandTrackListHandle input
  if (cx.GetDataIn()->InheritsFrom("CandTrackListHandle")) 
    {
      const CandTrackListHandle *ctlh = dynamic_cast<const CandTrackListHandle*>(cx.GetDataIn());
      const MomNavigator *mom = cx.GetMom();
      
      CandRecord* candrec = (CandRecord*)(cx.GetCandRecord());
      assert(candrec);
      
      VldContext* vldc = (VldContext*)(candrec->GetVldContext());
      Detector::Detector_t detector = vldc->GetDetector();


      // Create the new tracklist
      CandFitTrackCamListHandle& tracklist = dynamic_cast<CandFitTrackCamListHandle&>(ch);
      if( !ctlh || ctlh->GetNDaughters()<1 ) {
        // Require number of CandTracks to be non-zero to do anything more
        MSG("AlgFitTrackCamList", Msg::kWarning) << " !ctlh || ctlh->GetNDaughters()<1 " << endl;
        return;
      }



      // Make sure we pass the finder track with most strips to the fitter first of all
      // (important for ND Spectrometer DeMuxing)
      TIter trackItr(ctlh->GetDaughterIterator());

      int* NFinderStrips = new int[ctlh->GetNDaughters()]; 
      int index; int MaxFinderStrips; int id;
      
      for(index=0; index<ctlh->GetNDaughters(); ++index) {NFinderStrips[index]=-1;} 
      index=0;
      
      while (CandTrackHandle *track = dynamic_cast<CandTrackHandle*>(trackItr())) 
        {NFinderStrips[index]=track->GetNDaughters(); ++index;}



      // Set-up for calculating CPUTime
      clock_t dummyt;
      struct tms t1;
      struct tms t2;
      static double ticksPerSecond = sysconf(_SC_CLK_TCK);



      // Now loop over the ordered list of tracks, carrying out the fit
      for(int k=0; k<ctlh->GetNDaughters(); ++k) 
        {
          MaxFinderStrips=0; id=-1;
          for(index=0; index<ctlh->GetNDaughters(); ++index) {
            if(MaxFinderStrips<NFinderStrips[index]) {MaxFinderStrips=NFinderStrips[index]; id=index;} 
          }
          
          if(id>=0) {
            NFinderStrips[id]=-1; index=0; trackItr.Reset();
            
            CandTrackHandle *track = 0; 
            
            while (CandTrackHandle *track1 = dynamic_cast<CandTrackHandle*>(trackItr())) {
              if(index==id) {track=track1; break;} 
              ++index;
            }
            
            if(track!=0) {
              AlgFactory &af = AlgFactory::GetInstance();

              const char *configname;
              AlgHandle ah_trk;
              if (ac.Get("AlgFitTrackCamConfig", configname))
                ah_trk = af.GetAlgHandle("AlgFitTrackCam", configname);
              else
                ah_trk = af.GetAlgHandle("AlgFitTrackCam", "default");
              
              // Create complete track
              CandContext cx0(this, mom);
              cx0.SetDataIn(track);
              cx0.SetCandRecord(candrec);
              
              dummyt = times(&t1);
              CandFitTrackCamHandle cth = CandFitTrackCam::MakeCandidate(ah_trk, cx0);
              dummyt = times(&t2);
              cth.SetCPUTime((Double_t)(t2.tms_utime+t2.tms_stime-t1.tms_utime-t1.tms_stime)/ticksPerSecond);
              
              cth.SetName(TString("CandFitTrackCamHandle"));
              cth.SetTitle(TString("Created by AlgFitTrackCamList"));
              // Add candtrack to candtracklist
              tracklist.AddDaughterLink(cth);
              
              if(detector==Detector::kNear) {CleanNDSlices(candrec);}
            }
          }
        }
      delete[] NFinderStrips;

      if(detector==Detector::kNear) {CheckWeights(candrec);}


    }

}


void AlgFitTrackCamList::CleanNDSlices(CandRecord* candrec)
{
  // Check that there is nothing in slicelist that isn't in striplist
  bool SlushyOnEntry = CandHandle::IsSlushyEnabled();
  vector<CandStripHandle*> StripsToRemove;

  CandHandle::SetSlushyEnabled(kTRUE);

  CandStripListHandle* StripList = dynamic_cast<CandStripListHandle *> 
    (candrec->FindCandHandle("CandStripListHandle"));
        
  CandSliceListHandle* SliceList = dynamic_cast<CandSliceListHandle *> 
    (candrec->FindCandHandle("CandSliceListHandle"));


  if(SliceList && StripList) {
    CandSliceHandleItr sliceItr(SliceList->GetDaughterIterator());
          
    for (CandSliceHandle* Slice=sliceItr(); Slice ; Slice=sliceItr()) {
      CandStripHandleItr SliceStripItr(Slice->GetDaughterIterator());

      for (CandStripHandle* SliceStrip=SliceStripItr(); SliceStrip; SliceStrip=SliceStripItr()) {
        bool found = false;

        if(SliceStrip->GetPlane()>120){
          CandStripHandleItr stripItr(StripList->GetDaughterIterator());

          for (CandStripHandle* strip=stripItr(); strip ; strip=stripItr()) {
            if(strip->IsEqual(SliceStrip)) {found=true; break;}
          }
          if(!found) {StripsToRemove.push_back(SliceStrip);}
        }
      }
      for(unsigned int i=0; i<StripsToRemove.size(); ++i) {Slice->RemoveDaughter(StripsToRemove[i]);}
      StripsToRemove.clear();
    }
  }
        
  if(!SlushyOnEntry) {CandHandle::SetSlushyEnabled(kFALSE);}
}


void AlgFitTrackCamList::CheckWeights(CandRecord* candrec)
{
  // Make sure that the weights in the list of alternative PlexSEIds are
  // good after the ND Spectrometer DeMuxing is complete
  CandStripListHandle* StripList = dynamic_cast<CandStripListHandle *> 
    (candrec->FindCandHandle("CandStripListHandle"));

  if(StripList) {
    CandStripHandleItr stripItr(StripList->GetDaughterIterator());

    for (CandStripHandle* strip=stripItr(); strip ; strip=stripItr()) {
      if(strip->GetPlane()<121) {continue;}
      
      CandDigitHandleItr digitItr(strip->GetDaughterIterator());

      for (CandDigitHandle* digit=digitItr(); digit ; digit=digitItr()) {
        CandDigitHandle* newdig=digit->DupHandle();

        PlexSEIdAltL& newaltl=newdig->GetPlexSEIdAltLWritable();

        for(unsigned int i=0; i<newaltl.size(); ++i) {
          if(newaltl[i].GetWeight()>0) {newaltl[i].SetWeight((float)1.);}
        }
      }
    }
  }
}


void AlgFitTrackCamList::Trace(const char * /* c */) const
{
}

---