genDst.C

// $Id: genDst.C,v 1.9 2020/10/10 07:16:56 genevb Exp $
// Author: G. Van Buren (BNL)
//
// Description:
// Process a MuDst for...
// ...creating a PicoDst
// ...re-running vertex-finding to re-create MuDsts
//
// Options are space-separated or comma-separated,
// and case-insensitive. They can be attributed
// whose values are provided after a ':'.
//
// Example options for creating PicoDsts:
// picoDst
// btofMatch
// btofStartless
// mtdMatch
// y2017a
//
// Example lists of options:
// "picoDst"
// "DbV20200125,picoDst,mtdMatch,y2014a"
//
// Example options for vertex-finding:
// beamline, beamline1D, beamline3D (otherwise no beamline)
// useBTOFmatchOnly
// VFstore:100
//
// Example lists of options:
// "VFPPVnoCTB,beamline1D,VFstore:100"
// "VFPPVnoCTB,beamline3D"
//

void genDst(unsigned int Last,
            const char* options,
            char* infile,
            char* outfile=0);

void genDst(unsigned int First,
            unsigned int Last,
            const char* options,
            char* infile,
            char* outfile=0);

void loadLibs()
{
  gROOT->Macro("$STAR/StRoot/StMuDSTMaker/COMMON/macros/loadSharedLibraries.C");
  gSystem->Load("StDbBroker");
  gSystem->Load("St_db_Maker");
  gSystem->Load("StEEmcUtil");
}

void loadLibsVF()
{
  gSystem->Load("libMinuit");
  gSystem->Load("Sti");
  gSystem->Load("StBTofUtil");
  gSystem->Load("StGenericVertexMaker");
}

void loadLibsPico()
{

  // EMCs and FMS need DB+converters
  gSystem->Load("StEmcRawMaker");
  gSystem->Load("StEmcADCtoEMaker");
  gSystem->Load("StPreEclMaker");
  gSystem->Load("StEpcMaker");
  gSystem->Load("StEEmcDbMaker");
  gSystem->Load("StFmsUtil");
  gSystem->Load("StFmsDbMaker");
  gSystem->Load("StTriggerUtilities");

  // The PicoDst
  gSystem->Load("libStPicoEvent");
  gSystem->Load("libStPicoDstMaker");
}

void loadLibsAgML()
{
  // load support libraries.  util will fail to load for agml 1.0, but you can ignore the error
  gSystem->Load("libStarAgmlUtil");
  gSystem->Load("libStarAgmlLib");

  // load geometry modules and master steering codes...
  gSystem->Load("libGeometry");
  gSystem->Load("libStarGeometry");
}

void loadLibsMtd()
{
  gSystem->Load("StDetectorDbMaker");
  gSystem->Load("StarMagField");
  gSystem->Load("StMagF");
  gSystem->Load("StMtdUtil");
  gSystem->Load("StMtdMatchMaker");
  gSystem->Load("StMtdCalibMaker");
}

void loadLibsBTof()
{
  gSystem->Load("StBTofUtil");
  gSystem->Load("StVpdCalibMaker");
  gSystem->Load("StBTofCalibMaker");
  gSystem->Load("StBTofMatchMaker");
}

void loadLibsETof()
{
  gSystem->Load("StETofUtil");
  gSystem->Load("StETofCalibMaker");
  gSystem->Load("StETofHitMaker");
  gSystem->Load("StETofMatchMaker");
}

void procGeoTag(TObjArray* optionTokens)
{
  if (TClass::GetClass("AgBlock")) return; // arbitrarily chosen AgML class
  loadLibsAgML();

  const char* tag = 0;
  for (int tk=0; tk < optionTokens->GetEntries(); tk++) {
    TString& tok = ((TObjString*) (optionTokens->At(tk)))->String();
    if (tok.BeginsWith("y20")){
      tag = tok.Data();
      optionTokens->RemoveAt(tk);
      optionTokens->Compress();
      break;
    }  
  }

  // Let agml know we want the ROOT geometry
  AgModule::SetStacker( new StarTGeoStacker );

  // now pass the geometry "tag" and build.  If the class StarGeometry exists, we have
  // AgML 2.0 and can run using the new steering.  Otherwise, old steering codes...
  if (tag) {
    if ( TClass::GetClass("StarGeometry") ) {      StarGeometry::Construct( tag ); }
    else                                    {      ( new Geometry() )->ConstructGeometry(tag); }
  } else {
    gMessMgr->Warning() << "No geometry tag passed! (e.g. y2017a)" << endm;
  }
}

bool findAndRemoveOption(const char* optionName, TObjArray* optionTokens, bool doRemove=true)
{
  TString optName = optionName;
  optName.ToLower();
  TObject* obj = optionTokens->FindObject(optName.Data());
  if (obj) {
    if (doRemove) {
      optionTokens->Remove(obj);
      optionTokens->Compress();
    }
    return true;
  }
  return false;
}

bool findOption(const char* optionName, TObjArray* optionTokens)
{
   return findAndRemoveOption(optionName,optionTokens,false);
}

void genDst(unsigned int First,
            unsigned int Last,
            const char* options,
            char* infile,
            char* outfile)
{
  loadLibs();

  StChain fullChain("genDst");

  StMuDstMaker muDstMaker(0, 0, "", infile, "st:MuDst.root", 1e9); // set up maker in read mode
  //                      0, 0                        this means read mode
  //                           dir                    read all files in this directory
  //                               file               bla.lis read all file in this list, if (file!="") dir is ignored
  //                                    filter        apply filter to filenames, multiple filters are separated by ':'
  //                                          10      maximum number of file to read


  TChain& muDstChain = *muDstMaker.chain();
  unsigned int nEntries      = muDstChain.GetEntries();
  unsigned int LastToRead = Last > 0 ? min(Last, nEntries) : nEntries;
  gMessMgr->Info() << nEntries << " events in chain, " << LastToRead-First+1 << " will be read." << endm;

  St_db_Maker* db = new St_db_Maker("db", "StarDb", "MySQL:StarDb", "$STAR/StarDb");

  // Initialize some values and pointers
  StMaker* processMaker = 0;
  TFile* outFile = 0;
  TTree* muDstTreeOut = 0;

  // Basic decisions based on options
  TString CasedOptions = options;
  TString Options = options;
  Options.ToLower();
  TString optDelim = " ,";
  TObjArray* optionTokens = Options.Tokenize(optDelim);
  optionTokens->SetOwner(kTRUE);

  // Determine database flavors
  TString flavors = "ofl"; // default flavor for offline

  // FXT flavor
  if (findOption("FXT",optionTokens))
    flavors.Prepend("FXT+");

  // simulation flavors
  if (findAndRemoveOption("Simu",optionTokens) && ! findAndRemoveOption("NoSimuDb",optionTokens))
    flavors.Prepend("sim+");

  // filestream flavors
  TObject* firstFile = muDstChain.GetListOfFiles()->At(0);
  if (firstFile) {
    TString firstFileName = firstFile->GetTitle();
    firstFileName = firstFileName(firstFileName.Last('/')+1,firstFileName.Length());
    if (firstFileName.BeginsWith("st_")) {
      TString fileStream = firstFileName(3,firstFileName.Index('_',3)-3);
      if (fileStream.Length()>0) flavors.Prepend(fileStream += '+');
    }
  }
 
  gMessMgr->Info() << "Using DB flavors: " << flavors << endm;
  db->SetFlavor(flavors.Data());

  if (findAndRemoveOption("picodst",optionTokens)) {
    // _________________________________________________________________
    // Processing with generation of PicoDsts

    loadLibsPico();

    // Specify active branches but first disable all branches
    muDstMaker.SetStatus("*", 0);
    muDstMaker.SetStatus("MuEvent", 1);
    muDstMaker.SetStatus("PrimaryVertices", 1);
    muDstMaker.SetStatus("PrimaryTracks", 1);
    muDstMaker.SetStatus("GlobalTracks", 1);
    muDstMaker.SetStatus("CovGlobTrack", 1);
    muDstMaker.SetStatus("BTof*", 1);
    muDstMaker.SetStatus("Emc*", 1);
    muDstMaker.SetStatus("MTD*", 1);
    muDstMaker.SetStatus("ETof*", 1);
    muDstMaker.SetStatus("Epd*", 1);
    muDstMaker.SetStatus("Fms*", 1);
    muDstMaker.SetStatus("MCAll", 1);

    // EMCs
    StEEmcDbMaker* eemcDb = new StEEmcDbMaker;
    StEmcADCtoEMaker* adc2e = new StEmcADCtoEMaker();
    adc2e->saveAllStEvent(true);
    StPreEclMaker* pre_ecl = new StPreEclMaker();
    StEpcMaker* epc = new StEpcMaker();

    // FMS
    StFmsDbMaker* fmsDb = new StFmsDbMaker("fmsDb");

    // Trigger simulator
    StTriggerSimuMaker* trigSimu = new StTriggerSimuMaker;
    trigSimu->setMC(false);
    trigSimu->useBemc();
    trigSimu->useEemc();
    trigSimu->useOfflineDB();
    trigSimu->bemc->setConfig(StBemcTriggerSimu::kOffline);

    if (findAndRemoveOption("btofmatch",optionTokens)) {

      procGeoTag(optionTokens);
      loadLibsBTof();

      // instantiate both VPD and BTOF CalibMakers and MatchMaker and point them to the MuDST
      StBTofMatchMaker* btofMatch = new StBTofMatchMaker();
      btofMatch->setMuDstIn();
      StVpdCalibMaker *vpdCalib = new StVpdCalibMaker();
      vpdCalib->setMuDstIn();
      StBTofCalibMaker *btofCalib = new StBTofCalibMaker();
      btofCalib->setMuDstIn();

      if (findAndRemoveOption("btofstartless",optionTokens)) {
        //Disable the VPD as start detector, BTOF calib maker will switch to the "start-less" algorithm.
        vpdCalib->setUseVpdStart(kFALSE);
      }

      if (findOption("FXT",optionTokens)) {
        btofCalib->SetAttr("btofFXT", 1);
      }

    }

    if (findAndRemoveOption("etofmatch",optionTokens)) {

      procGeoTag(optionTokens);
      loadLibsETof();

      // instantiate eTOF CalibMakers, HitMaker and MatchMaker
      StETofCalibMaker* etofCalib = new StETofCalibMaker();
      StETofHitMaker*   etofHit   = new StETofHitMaker();
      StETofMatchMaker* etofMatch = new StETofMatchMaker();

    }

    if (findAndRemoveOption("mtdmatch",optionTokens)) {

      procGeoTag(optionTokens);
      loadLibsMtd();

      StMagFMaker* magfMk = new StMagFMaker;
      StMtdMatchMaker* mtdMatchMaker = new StMtdMatchMaker();
      StMtdCalibMaker* mtdCalibMaker = new StMtdCalibMaker("mtdcalib");

    }

    processMaker = (StMaker*) (new StPicoDstMaker(StPicoDstMaker::IoWrite, infile, "picoDst"));

  } else if (Options.Contains("vf")) {
    // _________________________________________________________________
    // Processing with new vertex-finding

    loadLibsVF();

    // Specify inactive branches but first enable all branches
    muDstMaker.SetStatus("*",1);
    muDstMaker.SetStatus("PrimaryTracks",0);
    muDstMaker.SetStatus("PrimaryVertices",0);

    // Create new branch
    TClonesArray* verticesRefitted = new TClonesArray("StMuPrimaryVertex", 1000);

    // Specify output
    if (outfile) {
      outFile = new TFile(outfile, "RECREATE");
    } else {
      // Use the same filename for output as was given by input
      TString fileStr = infile;
      Ssiz_t dir = fileStr.Last('/');
      if (dir<0) {
        gMessMgr->Error() << "No specification for output when input is in local directory!" << endm;
        return;
      }
      fileStr.Remove(0,dir+1);
      outFile = new TFile(fileStr.Data(), "RECREATE");
    }
    muDstTreeOut = muDstChain.CloneTree(0);
    muDstTreeOut->Branch("PrimaryVertices", &verticesRefitted, 65536, 99);

    processMaker = (StMaker*) (new StGenericVertexMaker());
    processMaker->ToWhiteConst("vtxArray",verticesRefitted);
    processMaker->SetAttr("useMuDst",1);

  } else {

    gMessMgr->Info() << "No processing specified - just reading a MuDst?" << endm;
    // User code may be inserted here

  }

  // Set additional options (except DbV) as maker attributes
  if (processMaker) {
    for (int tk=0; tk < optionTokens->GetEntries(); tk++) {
      TString& Tag = ((TObjString*) (optionTokens->At(tk)))->String();

      // copy of DbV code from StBFChain.cxx
      if (Tag.BeginsWith("dbv")) {
        int FDate=0,FTime=0;
        if (Tag.Length() == 11)  (void) sscanf(Tag.Data(),"dbv%8d",&FDate);
        if (Tag.Length() == 18)  (void) sscanf(Tag.Data(),"dbv%8d.%6d",&FDate,&FTime);
        if (FDate) {
          db->SetMaxEntryTime(FDate,FTime);
          gMessMgr->Info() << "\tSet DataBase max entry time " << FDate << "/" << FTime
                           << " for St_db_Maker(\"" << db->GetName() <<"\")" << endm;
        }
        continue;
      }

      // assign attributes
      StMaker* attrMaker = processMaker;
      Ssiz_t delim = Tag.First(':');
      // look for "::" to set attributes for a different maker
      if (delim > 0 && Tag[delim+1] == ':') {
        TString altMakerName = Tag(0,delim);
        // GetMaker...() functions are case sensitive, so find original case
        Ssiz_t casedMakerNameIdx = CasedOptions.Index(altMakerName,0,TString::ECaseCompare::kIgnoreCase);
        if (casedMakerNameIdx >= 0) altMakerName = CasedOptions(casedMakerNameIdx,delim);
        StMaker* altMaker = fullChain.GetMaker(altMakerName.Data());
        if (!altMaker) altMaker = fullChain.GetMakerInheritsFrom(altMakerName.Data());
        if (!altMaker) {
          gMessMgr->Warning() << "No maker found with name or class " << altMakerName.Data() << endm;
          continue;
        }
        attrMaker = altMaker;
        Tag.Remove(0,delim+2);
        delim = Tag.First(':');
      }
      if (delim < 0) {
        attrMaker->SetAttr(Tag.Data(),1);
      } else {
        TString key(Tag(0,delim));
        TString& val = Tag.Remove(0,delim+1);
        if (val.IsDigit()) { attrMaker->SetAttr(key.Data(),val.Atoi()); }
        else if (val.IsFloat()) { attrMaker->SetAttr(key.Data(),val.Atof()); }
        else { attrMaker->SetAttr(key.Data(),val.Data()); }
      }
    }
    processMaker->PrintAttr();
  }

  {
    TDatime t;
    gMessMgr->QAInfo() << Form("Run is started at Date/Time %i/%i",t.GetDate(),t.GetTime()) << endm;
  }
  gMessMgr->QAInfo() << Form("Run on %s in %s",gSystem->HostName(),gSystem->WorkingDirectory()) << endm;
  gMessMgr->QAInfo() << Form("with %s", fullChain.GetCVS()) << endm;


  // Main loop over events
  int iInit = fullChain.Init();
  if (iInit >= kStEOF) {fullChain.FatalErr(iInit,"on init"); return;}
  if (Last == 0) return;
  int eventCount = 0;
  // Skip, if any
  if (First > 1) fullChain.Skip(First - 1);
  for (unsigned int iEvent = First; iEvent <= LastToRead; iEvent++)
  {
     int iMake = fullChain.Make();
     if (iMake) {fullChain.FatalErr(iMake,"on make"); return;}

     if (muDstTreeOut) muDstTreeOut->Fill();

     int iClear = fullChain.Clear();
     if (iClear) {fullChain.FatalErr(iClear,"on clear"); return;}
     eventCount++;
  }
  fullChain.Finish();

  //
  // ATTENTION - please DO NOT change the format of the next 2 lines,
  //   they are used by our DataManagement parsers to detect a generation 
  //   was succesful and thereafter Catalog the produced files.
  //   Thank you.
  //
  gMessMgr->QAInfo() << "NumberOfEvents= " << eventCount << endm;
  gMessMgr->QAInfo() << "Run completed " << endm;

  if (outFile) {
    outFile->Write();
    outFile->Close();
    delete outFile;
  }

  delete db;
  delete processMaker;
  delete optionTokens;
}

//__________________________________________________________
void genDst(unsigned int Last,
            const char* options,
            char* infile,
            char* outfile)
{
  genDst(1,Last,options,infile,outfile);
}

//
// $Log: genDst.C,v $
// Revision 1.10  2022/05/12 07:16:56  weidenkaff
// Added eTOF support
//
// $Log: genDst.C,v $
// Revision 1.9  2020/10/10 07:16:56  genevb
// Specify makers to set attributes
//
// Revision 1.8  2020/08/19 15:27:33  genevb
// Add DB flavors
//
// Revision 1.7  2020/01/25 05:10:00  genevb
// Include DbV, more like BFC
//
// Revision 1.6  2019/09/18 17:54:48  genevb
// Acivate additional branches by default
//
// Revision 1.5  2019/03/21 18:53:34  jeromel
// Added ATTENTION message
//
// Revision 1.4  2019/01/15 17:24:29  genevb
// Added FMS
//
// Revision 1.3  2018/03/16 18:41:14  genevb
// Add BTof-matching
//
// Revision 1.2  2017/12/15 18:36:53  genevb
// Remove explicit function of StPicoDstMaker...params should be passed by attribute
//
// Revision 1.1  2017/12/05 16:47:58  genevb
// Introduce genDst.C for creating new Dsts from MuDsts
//
//