ComputeJobProcDataTime.C

Go to the documentation of this file.

/*
# Copyright (C) 2019 Gabriele Vedovato
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
 
//
// this macro is used to compute the effective observational time processed with jobs at zero lag after cat1 & cat2 subtraction
//  -> produces a file with list of standard/extended (fixed/variable length) segments
//
 
#define HOUR   3600.
#define DAY (24.*3600.)
#define  SEGMLS  200    // used for extended segments
 
bool sortByName(const string &ifo1, const string &ifo2) { return ifo1 < ifo2; }
 
void ComputeJobProcDataTime(TString type, TString parameter1, TString parameter2="", TString parameter3="", TString parameter4="") {
 
  TString chunk;
  TString odir="";
  TString olabel="";
 
  TString ifname1;
  TString ifname2;
 
  TString ofname;
 
  if(type!="standard" && type!="extended" && type!="exclusive") {
    cout << "ComputeJobProcDataTime.C - Error: allowed input type must be standard/extended/exclusive" << endl;
    exit(1);
  }
 
  CWB::Toolbox TB;
  vector<waveSegment> segList;
  double seg_time;
 
  vector<TString> ifos(nIFO);
  for(int n=0;n<nIFO;n++) {
    if(strlen(ifo[n])!=0) ifos[n]=ifo[n];           // built in detector
    else                  ifos[n]=detParms[n].name; // user define detector
  }
 
  // sort detector names
  vector<string> uifos(nIFO); // unsorted ifos
  for(int i=0;i<nIFO;i++) uifos[i]=ifos[i].Data();
  sort(uifos.begin(), uifos.end(), sortByName);
  TString sifos[3];     // sorted ifos
  int n=0; for(string &ifo : uifos) sifos[n++]=ifo.c_str();
  //for(int i=0;i<nIFO;i++) cout << i << " -------------------> SORTED " << sifos[i] << endl;
 
  // set name label for output file
  TString snet = sifos[0];
  for(int i=1;i<nIFO;i++) snet += "_"+sifos[i];
 
  if(type=="exclusive") {
 
    ifname1  = parameter1;
    ifname2  = parameter2;
    odir     = parameter3;
    olabel   = parameter4;
 
    vector<waveSegment> seg1 = TB.readSegments(ifname1); // read segments 1
    double seg1_time = TB.getTimeSegList(seg1);
    cout << "seg1_time = " << (int)seg1_time << " sec - " << seg1_time/DAY << " days" << endl;
 
    vector<waveSegment> seg2 = TB.readSegments(ifname2); // read segments 2
    double seg2_time = TB.getTimeSegList(seg2);
    cout << "seg2_time = " << (int)seg2_time << " sec - " << seg2_time/DAY << " days" << endl;
 
    vector<waveSegment> iseg2 = TB.invertSegments(seg2);       // compute inverse iseg2 segments
 
    vector<waveSegment> xseg12 = TB.mergeSegLists(seg1,iseg2); // compute the exclusive time of seg1 wrt seg2
    double xseg12_time = TB.getTimeSegList(xseg12);
    cout << "xseg12_time = " << (int)xseg12_time << " sec - " << xseg12_time/DAY << " days" << endl;
 
    segList = xseg12;
    seg_time = xseg12_time;
    snet="exclusive";
 
    ofname = ifname1;
    TString label = olabel!="_not" ? "_not_"+olabel : ""; 
    ofname.ReplaceAll(".txt",label+".txt");
  }
 
  if(type=="standard" || type=="extended") {
 
    chunk  = parameter1;
    odir   = parameter2;
    olabel = parameter3;
 
    // extract cat0 segments
    vector<waveSegment> cat0List=TB.readSegList(nDQF, DQF, CWB_CAT0);
    double cat0_time=TB.getTimeSegList(cat0List);
    cout << "total livetime after cat0: " << int(cat0_time) << " sec " 
       << cat0_time/HOUR << " h " << cat0_time/DAY << " days" << endl;
    cout << endl;
 
    // extract cat1 segments
    vector<waveSegment> cat1List=TB.readSegList(nDQF, DQF, CWB_CAT1);
    double cat1_time=TB.getTimeSegList(cat1List);
    cout << "total livetime after cat1: " << int(cat1_time) << " sec " 
         << cat1_time/HOUR << " h " << cat1_time/DAY << " days" << endl;
    cout << endl;
 
    // extract cat2 segments
    vector<waveSegment> cat2List=TB.readSegList(nDQF, DQF, CWB_CAT2);
    double cat2_time=TB.getTimeSegList(cat2List);
    cout << "total livetime after cat2: " << int(cat2_time) << " sec " 
         << cat2_time/HOUR << " h " << cat2_time/DAY << " days" << endl;
    cout << endl;
 
    // extract job segments
    if(type=="standard") {
      vector<waveSegment> jobList=TB.getSlagJobList(cat1List, segLen);
      int slagSegs=jobList.size();
      vector<slag> rslagList;
      // full slag list: force slagSize=1, slagFile=NULL
      vector<slag> slagList=TB.getSlagList(nIFO, 1, slagSegs, slagOff, slagMin, slagMax, slagSite, NULL);
      cout << "slagList size : " << slagList.size() << endl;
      // reduced slag list (removed slag with max segLength < segMSL after cat1 & segLength < segTHR after cat2)
      cout << endl << "Start segments selection from dq cat1 list ..." << endl << endl;
      rslagList=TB.getSlagList( slagList, ifos, segLen, segMLS, segEdge, nDQF, DQF, CWB_CAT1);
      cout << "Number of selected jobs after cat1 : " << rslagList.size() << endl;
      cout << endl << "Start segments selection from dq cat2 list ..." << endl << endl;
      rslagList=TB.getSlagList(rslagList, ifos, segLen, segTHR, segEdge, nDQF, DQF, CWB_CAT2);
      cout << "Number of selected jobs after cat2 : " << rslagList.size() << endl;
 
      slag SLAG; 
      waveSegment SEG;
      vector<waveSegment> tmpList;
 
      for(int i=0;i<rslagList.size();i++) {
  
        SLAG = rslagList[i]; 
 
        // get range segment for this job intersecting with cat1 list (cat1List)
        SEG.start = jobList[SLAG.segId[0]-1].start-segEdge;
        SEG.stop  = jobList[SLAG.segId[0]-1].stop+segEdge;
        tmpList.clear();
        tmpList.push_back(SEG);
        tmpList = TB.mergeSegLists(cat1List,tmpList);    // merge detector segments with dq cat1
        SEG = TB.getMaxSeg(tmpList);                     // extract max length segment (only this segment is used for analysis)
        int segLength=SEG.stop-SEG.start;
        if(segLength>=segMLS+2*segEdge) {
          SEG.start+=segEdge;
          SEG.stop-=segEdge;
          segList.push_back(SEG);
        }
      }
 
      char fname[1024];
      TString label = olabel!="" ? "_"+olabel : ""; 
      sprintf(fname,"%s/K%s_sjobs_%s_cat012%s.txt",odir.Data(),chunk.Data(),snet.Data(),label.Data());
      ofname=fname;
    }
 
    if(type=="extended") {
      vector<waveSegment> jobList=TB.getJobList(cat1List, cat2List, segLen, SEGMLS, segTHR, segEdge);
      cout<<endl<<"Final number of extended jobs : " << jobList.size() <<endl<<endl;
      segList=jobList;
 
      char fname[1024];
      TString label = olabel!="" ? "_"+olabel : ""; 
      sprintf(fname,"%s/K%s_ejobs_%s_cat012%s.txt",odir.Data(),chunk.Data(),snet.Data(),label.Data());
      ofname=fname;
    }
 
    cout.precision(6);
 
    double job_time=TB.getTimeSegList(segList);
    cout << "cat1 livetime (zero lag) of the standard job list : " << int(job_time) << " sec " 
         << job_time/HOUR << " h " << job_time/DAY << " days" << endl;
    cout << endl;
 
    segList = TB.mergeSegLists(segList,cat2List);
    double job_time_cat2=TB.getTimeSegList(segList);
    cout << "cat1+cat2 livetime (zero lag) of the standard job list : " << int(job_time_cat2) << " sec "
         << job_time_cat2/HOUR << " h " << job_time_cat2/DAY << " days" << endl;
 
    seg_time = job_time_cat2;
  }
 
  if(odir!="") {
 
    // remove segment with zero length 
    vector<waveSegment> osegList;
    for(int i=0;i<segList.size();i++) {
      if(segList[i].stop > segList[i].start) osegList.push_back(segList[i]);
    }
 
    // output job list file
    cout<<"Dump segment list : includes jobs discarted by the condition livetime<segTHR"<<endl;
    TB.dumpSegList(osegList,ofname);
 
    // dump to README.md file
    ofstream out;
    if(TB.isFileExisting("README.md")) {
      out.open("README.md",ios::app);  // append
    } else {
      out.open("README.md",ios::out);  // create
    }
    if(!out.good()) {cout << "ComputeJobProcDataTime.C - Error : Opening File : "
                          << "README.md" << endl;gSystem->Exit(1);}
    out.precision(6);
    out << "--------------------------------------------------------------------------" << endl;
    if(type=="exclusive") out << snet << " network exclusive time after cat0+cat1+cat2 on standard segments" << endl;
    if(type=="standard")  out << snet << " network coincident time after cat0+cat1+cat2 on standard segments" << endl;
    if(type=="extended")  out << snet << " network coincident time after cat0+cat1+cat2 on extended segments" << endl;
    out << "--------------------------------------------------------------------------" << endl;
    out << endl;
    out << snet << "_time = " << (int)seg_time << " sec - " << seg_time/DAY << " days" << endl;
    out << "-> " << gSystem->BaseName(ofname) << endl << endl;
    out.close();
  }
  cout << endl;
 
  exit(0);
}