TBasicHeaderModule.cxx

Go to the documentation of this file.

///
/// For questions or suggestions about this module please contact the
/// current responsible and CC in the eventAnalysis package manager.
///
/// 23-May-2014: Current responsible for this module is,
/// Luke Pickering (lp208 [*a*t*] ic.ac.uk)
// include to get environment variables for software version
#include <cstdlib>
#include "TRegexp.h"
#include "TString.h"
#include "TBasicHeaderModule.hxx"
#include "TG4PrimaryParticle.hxx"
#include "TG4PrimaryVertex.hxx"
#include "TIntegerDatum.hxx"
#include "TND280MCHeader.hxx"
#include "TRealDatum.hxx"
#include <iostream>     // std::cout
#include <fstream>      // std::ifstream
#include "dirent.h"

#include "../cvstags/TBasicHeaderModule.cxx"


ND::TBasicHeaderModule::TBasicHeaderModule(const char *name,

                                           const char *title) {
  SetNameTitle(name, title);
  // Enable this module by default:
  fIsEnabled = kTRUE;
  fDescription =
      "Standard module which fills the standard header information "
      "about an event";
  fCVSTagName = CVSTAG;
  fCVSID = CVSID;
  fSoftware = true;
  fSoftwareUseOverrideVersion = false;

  ND::TFieldManager::InitializeFieldManager();
}
ND::TBasicHeaderModule::~TBasicHeaderModule() {}



Bool_t ND::TBasicHeaderModule::Configure(std::string &option) 
{
  ND280NamedWarn("TBasicHeaderModule"," Configure");
  ND280NamedWarn("TBasicHeaderModule"," options"<<option);


  if (option == "noVersion") {
    ND280NamedWarn("TBasicHeaderModule"," NOT storing software version number in output TTree");
    fSoftware = false;
    return true;
  }

  if (option.find("OverrideSWVersion") == 0) 
  {
    TRegexp OverrideVersionREGEXOld("^OverrideSWVersion_v[0-9]+r?[0-9]*p?[0-9]*$");
    TRegexp OverrideVersionREGEXNew("^OverrideSWVersion_[0-9]+[.][0-9]+[.]*[0-9]*$");
    TString optTS = option;
    bool OldStyle=kFALSE;
    bool NewStyle=kFALSE;
    if (optTS.Contains(OverrideVersionREGEXOld) )OldStyle=kTRUE;
    if (optTS.Contains(OverrideVersionREGEXNew) )NewStyle=kTRUE;
    if(OldStyle || NewStyle) fSoftwareUseOverrideVersion = true;
    // Call me paranoid but we wouldn't want to cause buffer overflows...
    size_t len = (option.size() - option.find_first_of('_'));
    if (len > 49) {
      ND280NamedError(
        "TBasicHeaderModule",
        "The supplied option "
        << option.substr(option.find_first_of('_'), std::string::npos)
        << " is too long, please use a shorter version numb"
        "er.");
      return false;
    }
    if (fSoftwareUseOverrideVersion)
    {
      fSoftwareOverrideVersionString =
      option.substr(option.find_first_of('_') + 1, std::string::npos);
      ND280NamedLog("TBasicHeaderModule",
        "Software Version override found version : " << fSoftwareOverrideVersionString);
      return true;
    }
    else
    {
      ND280NamedError("TBasicHeaderModule",
        "Found option \"" << option
        << "\""
        " which is malformed, should be "
        "matched by ^OverrideVersion_v[0-9]+"
        "r?[0-9]*p?[0-9]*$"
        " or "
        "^OverrideSWVersion_"
        "[0-9]+[.][0-9]+[.]*[0-9]*$"
        );
      return false;
    }

  }
  if (option  == "software_version")  {
    ND280NamedWarn("TBasicHeaderModule"," Storing software version deduced from environment variables");
    fSoftware = true;
    return true;
  }

  // unrecognised option found
  ND280Error(""<<"TBasicHeaderModule argument \""<<option<<"\" is not valid. "<<std::endl<<" Valid values are:  noVersion, software_version ( uses environment variables) , or "<<std::endl<<
    " matching regular expression: OverrideVersion_v[0-9]+r?[0-9]*p?[0-9]  or OverrideSWVersion_[0-9]+[.][0-9]+[.]*[0-9]"
    );
  return false;
}
void ND::TBasicHeaderModule::InitializeBranches() {
// HEADER INFO
    fOutputTree->Branch("EventTime", &fEventTime, "EventTime/i", fBufferSize);
    fOutputTree->Branch("TriggerWord", &fTriggerWord, "TriggerWord/l",
        fBufferSize);
    fOutputTree->Branch("FGDCosmicEvent", &fFGDCosmicEvent, "FGDCosmicEvent/O",
        fBufferSize);
    fOutputTree->Branch("TripTCosmicEvent", &fTripTCosmicEvent,
        "TripTCosmicEvent/O", fBufferSize);
    fOutputTree->Branch("CTMTriggerPattern", fCTMTriggerPattern,
        "CTMTriggerPattern[3]/l", fBufferSize);
    fOutputTree->Branch("TripTCosmicTriggerType", &fTripTCosmicTriggerType,
        "TripTCosmicTriggerType/I", fBufferSize);
    fOutputTree->Branch("TripTCosmicTriggerUpward", &fTripTCosmicTriggerUpward,
        "TripTCosmicTriggerUpward/I", fBufferSize);
    fOutputTree->Branch("CosmicPrescaleWeight", &fCosmicPrescaleWeight,
        "CosmicPrescaleWeight/D", fBufferSize);
    fOutputTree->Branch("SoftwareVersion", fSoftwareVersion, "SoftwareVersion/C",
        fBufferSize);
    fOutputTree->Branch("MagneticFieldStrength", &fMagneticFieldStrength,
        "MagneticFieldStrength/D", fBufferSize);
// Get context info
    fOutputTree->Branch("Partition", &fPartition, "Partition/I", fBufferSize);
    fOutputTree->Branch("Spill", &fSpill, "Spill/I", fBufferSize);
    fOutputTree->Branch("TimeStamp", &fTimeStamp, "TimeStamp/I", fBufferSize);
    fOutputTree->Branch("IsDetector", &fIsDetector, "IsDetector/O", fBufferSize);
    fOutputTree->Branch("IsMC", &fIsMC, "IsMC/O", fBufferSize);
// fOutputTree->Branch("IsSand", &fIsSand,
//                     "IsSand/O", fBufferSize);
    fOutputTree->Branch("P0DWaterStatus", &fP0DWaterStatus, "P0DWaterStatus/O",
        fBufferSize);
    fOutputTree->Branch("GeometryHash", fGeometryHash, "GeometryHash[5]/i",
        fBufferSize);
    fOutputTree->Branch("AlignmentId", fAlignmentId, "fAlignmentId[5]/i",
        fBufferSize);
// MC header information
    fOutputTree->Branch("POTPerSpill", &fMCIntensity, "POTPerSpill/F",
        fBufferSize);
}

bool ND::TBasicHeaderModule::FillTree(ND::TND280Event &event) {

  ND280Warn(" entered ND::TBasicHeaderModule::FillTree ");
  ND280NamedWarn("TBasicHeaderModule",
   "Entered ND::TBasicHeaderModule::FillTree ");
  ND::TND280Context context = event.GetContext();

  fPartition = context.GetPartition();
  fSpill = context.GetSpill();
  fTimeStamp = context.GetTimeStamp();
  fIsDetector = context.IsDetector();
  fIsMC = context.IsMC();
  fIsSand = fIsMC && ((context.GetRun() / 1000) % 10 == 7);
  fP0DWaterStatus = this->P0DWaterStatus();

  ND::TSHAHashValue geoHash = event.GetGeometryHash();
  ND::TAlignmentId alignId = event.GetAlignmentId();
  for (std::size_t i = 0; i < 5; ++i) {
    fGeometryHash[i] = geoHash(i);
    fAlignmentId[i] = alignId(i);
  }

  fMCIntensity = 0;
  if (event.Get<ND::TND280MCHeader>("truth/mcHeader")) {
    fMCIntensity =
    event.Get<ND::TND280MCHeader>("truth/mcHeader")->GetIntensity();
  }
  
  if(fSoftware)
    ND280NamedWarn("TBasicHeaderModule"," fSoftware is true ");
  else 
    ND280NamedWarn("TBasicHeaderModule"," fSoftware is false ");
  if(fSoftwareUseOverrideVersion)
    ND280NamedWarn("TBasicHeaderModule",
      " fSoftwareUseOverrideVersion is true - will use value from command line. ");
  if (fSoftware)
    {
      if ( fSoftwareUseOverrideVersion){
     strcpy(fSoftwareVersion, fSoftwareOverrideVersionString.c_str());
     ND280NamedInfo("TBasicHeaderModule",
       "SoftwareVersion branch will be set "
       "as: "
       << fSoftwareOverrideVersionString);
   }
   else
   {
    char *softwareVersionCharOld = getenv("ND280ROOT");
    char *softwareVersionCharNew = getenv("ND280SOFTWAREMASTERROOT");

    if( softwareVersionCharNew  != NULL )
    {
      std::string softwareVersionString = softwareVersionCharNew;
      size_t lastUnderscore = softwareVersionString.find_last_of("_");
      softwareVersionString = softwareVersionString.substr(lastUnderscore + 1);
      // check format of softwareVersionString is valid n.n[.n]
      TRegexp VersionREGEXNew("^[0-9]+[.][0-9]+[.]*[0-9]*$");
      TString optTS(softwareVersionString);
      if (optTS.Contains(VersionREGEXNew) )
        {
          strcpy(fSoftwareVersion, softwareVersionString.c_str());
          ND280NamedInfo("TBasicHeaderModule",
           "Software Version found from ND280SOFTWAREMASTERROOT : " << softwareVersionString);
        }
        else
        {
         strcpy(fSoftwareVersion, "NULL");
         ND280NamedWarn("TBasicHeaderModule",
          "Software version number "<<optTS<<" found from ND280SOFTWAREMASTERROOT is not correctly formatted "<<
           "so setting fSoftwareVersion to \"NULL\"");
       }
    }
    else if  (softwareVersionCharOld != NULL ) 
    {
      std::string softwareVersionString = softwareVersionCharOld;
      size_t lastSlash = softwareVersionString.find_last_of("/");
      softwareVersionString = softwareVersionString.substr(lastSlash + 1);
      strcpy(fSoftwareVersion, softwareVersionString.c_str());
      ND280NamedInfo("TBasicHeaderModule",
       "Software Version found from ND280ROOT: " << softwareVersionString);
    }
    else
    {
      strcpy(fSoftwareVersion, "NULL");
      ND280NamedWarn("TBasicHeaderModule",
       "Couldn't find ND280ROOT or ND280SOFTWAREMASTERROOT, setting "
       "fSoftwareVersion to \"NULL\"");
    }
  } 
}
else 
{
  strcpy(fSoftwareVersion, "NULL");
  ND280NamedWarn("TBasicHeaderModule",
   "Software version command line option noVersion "
   "set so , setting fSoftwareVersion to \"NULL\"");
}
fEventTime = event.GetHeader().GetMCMSecond();

fTriggerWord = event.GetHeader().GetTriggerWord();
ULong64_t one = 1;
ULong64_t shift = one << 55;
fTripTCosmicEvent = shift & fTriggerWord;
shift = one << 56;
fFGDCosmicEvent = shift & fTriggerWord;

fMagneticFieldStrength =
ND::TFieldManager::GetFieldValue(TVector3(0, 0, -400.0)).Mag();

for (int i = 0; i < 3; i++) {
  fCTMTriggerPattern[i] = event.GetHeader().GetCTMTriggerPattern(i);
}

fTripTCosmicTriggerType = -1;
if (event.Has<ND::TIntegerDatum>("triptCosmicTriggerType")) {
  fTripTCosmicTriggerType =
  event.Get<ND::TIntegerDatum>("triptCosmicTriggerType")->GetValue();
}

fTripTCosmicTriggerUpward = -1;
if (event.Has<ND::TIntegerDatum>("triptCosmicTriggerUpward")) {
  fTripTCosmicTriggerUpward =
  event.Get<ND::TIntegerDatum>("triptCosmicTriggerUpward")->GetValue();
}

fCosmicPrescaleWeight = 1;
if (event.Has<ND::TRealDatum>("CosmicPrescaleWeight")) {
  fCosmicPrescaleWeight =
  event.Get<ND::TRealDatum>("CosmicPrescaleWeight")->GetValue();
}

return true;

}

Bool_t ND::TBasicHeaderModule::ProcessFirstEvent(ND::TND280Event &) {
    return true;
}
bool ND::TBasicHeaderModule::P0DWaterStatus() {
    double depth = ND::TGeomInfo::Get().P0D().TargetDepth();
    if (depth < 1000.0) {
        return false;
    } else {
        return true;
    }
}