loon: Header.cxx Source File

00001 // $Id: Header.cxx,v 1.21 2009/10/09 20:26:51 jyuko Exp $
00002 
00003 // C/C++
00004 #include <cassert>
00005 #include <iostream>
00006 #include <iomanip>
00007 #include <sstream>
00008 
00009 // MINOS
00010 #include "Conventions/ReleaseType.h"
00011 
00012 // Local
00013 #include "Header.h"
00014 
00015 using namespace std;
00016 
00017 //---------------------------------------------------------------------------------------------
00018 Anp::Header::Header()
00019    :run(-1),
00020     subrun(-1),
00021     snarl(-1),
00022     timeframe(-1),
00023     sec(-1),
00024     nsec(-1),
00025     trigger(-1),
00026     spilltype(-1),
00027     detector(-1),
00028     simflag(-1),
00029     runperiod(-1),
00030     relitype(-1),
00031     spillsec(-1),
00032     spillnsec(-1),
00033     gpstime(-1),
00034     gpserror(-1),
00035     litime(-1),
00036     cratemask(-1),
00037     beamdsec(-1),
00038     beamdnsec(-1),
00039     tor101(-1.0e6),
00040     tr101d(-1.0e6),
00041     tortgt(-1.0e6),
00042     trtgtd(-1.0e6),
00043     coilcur(-1.0e6),
00044     time2spill(-1.0e6),
00045     coilrevs(false),
00046     goodbeam(false),
00047     goodcoil(false),
00048     gooddetc(false),
00049     valid(false)
00050 {
00051    Header::SetBeamType("Unknown");
00052 }
00053 
00054 //---------------------------------------------------------------------------------------------
00055 Anp::Header::~Header()
00056 {
00057 }
00058 
00059 //---------------------------------------------------------------------------------------------
00060 void Anp::Header::Clear()
00061 {
00062    run        = -1;
00063    subrun     = -1;
00064    snarl      = -1;
00065    timeframe  = -1;
00066    sec        = -1;
00067    nsec       = -1;
00068    trigger    = -1;
00069    spilltype  = -1;
00070    detector   = -1;
00071    simflag    = -1;
00072    runperiod  = -1;
00073    relitype   = -1;
00074    spillsec   = -1;
00075    spillnsec  = -1;
00076    gpstime    = -1;
00077    gpserror   = -1;
00078    litime     = -1;
00079    cratemask  = -1;
00080    beamdsec   = -1;
00081    beamdnsec  = -1;
00082    tor101     = -1.0e6;
00083    tr101d     = -1.0e6;
00084    tortgt     = -1.0e6;
00085    trtgtd     = -1.0e6;
00086    coilcur    = -1.0e6;
00087    time2spill = -1.0e6;
00088    coilrevs   = false;
00089    goodbeam   = false;
00090    goodcoil   = false;
00091    gooddetc   = false;
00092    goodhv     = false;
00093    valid      = false;
00094 
00095    Header::SetBeamType("Unknown");
00096 }
00097 
00098 //---------------------------------------------------------------------------------------------
00099 bool Anp::Header::IsData() const
00100 {
00101    if(simflag == 1) return true;
00102    else if(simflag == 2) return false;
00103    
00104    cerr << "Header::IsData - unknown simflag value: " << simflag << endl;
00105 
00106    return false;
00107 }
00108 
00109 //---------------------------------------------------------------------------------------------
00110 bool Anp::Header::IsNear() const
00111 {
00112    if(detector == 1) return true;
00113    else if(detector == 2) return false;
00114    
00115    cerr << "Header::IsNear - unknown detector value: " << detector << endl;
00116 
00117    return false;
00118 }
00119 
00120 //---------------------------------------------------------------------------------------------
00121 bool Anp::Header::IsFar() const
00122 {
00123    if(detector == 1) return false;
00124    else if(detector == 2) return true;
00125    
00126    cerr << "Header::IsFar - unknown detector value: " << detector << endl;
00127 
00128    return false;
00129 }
00130 
00131 //---------------------------------------------------------------------------------------------
00132 long double Anp::Header::BeamDTime() const
00133 {
00134    //
00135    // Return beam spill time in seconds
00136    //
00137    return static_cast<long double>(beamdsec) + 1.0e-9*static_cast<long double>(beamdnsec);
00138 }
00139 
00140 //---------------------------------------------------------------------------------------------
00141 long double Anp::Header::SpillTime() const
00142 {
00143    //
00144    // Return beam spill time in seconds
00145    //
00146    return static_cast<long double>(spillsec) + 1.0e-9*static_cast<long double>(spillnsec);
00147 }
00148 
00149 //---------------------------------------------------------------------------------------------
00150 long double Anp::Header::TriggTime() const
00151 {
00152    //
00153    // Return trigger time in seconds
00154    //
00155    return static_cast<long double>(sec) + 1.0e-9*static_cast<long double>(nsec);
00156 }
00157 
00158 //---------------------------------------------------------------------------------------------
00159 void Anp::Header::Print(ostream& o) const
00160 {
00161    o << "Header::Print" << endl
00162      << "   run, subrun, snarl = " << run << ", " << subrun << ", " << snarl << endl
00163      << "   timeframe  = " << timeframe << endl
00164      << "   sec        = " << sec << endl
00165      << "   nsec       = " << nsec << endl
00166      << "   trigger    = " << trigger << endl
00167      << "   detector   = " << detector << endl
00168      << "   simflag    = " << simflag << endl
00169      << "   runperiod  = " << runperiod << endl
00170      << "   relitype   = " << relitype << endl
00171      << "   gpstime    = " << gpstime << endl
00172      << "   gpserror   = " << gpserror << endl
00173      << "   litime     = " << litime  << endl
00174      << "   cratemask  = " << cratemask << endl
00175      << "   spillsec   = " << spillsec << endl
00176      << "   spillnsec  = " << spillnsec << endl
00177      << "   beamdsec   = " << beamdsec << endl
00178      << "   beamdnsec  = " << beamdnsec << endl
00179      << "   tor101     = " << tor101 << endl
00180      << "   tr101d     = " << tr101d << endl
00181      << "   tortgt     = " << tortgt << endl
00182      << "   trtgtd     = " << trtgtd << endl
00183      << "   coilcur    = " << coilcur << endl
00184      << "   time2spill = " << time2spill << endl
00185      << "   beamtype   = " << GetBEAMTYPE() << endl
00186      << "   coilrevs   = " << coilrevs << endl
00187      << "   goodbeam   = " << goodbeam << endl
00188      << "   goodcoil   = " << goodcoil << endl
00189      << "   gooddetc   = " << gooddetc << endl
00190      << "   goodhv     = " << goodhv << endl
00191      << "   valid      = " << valid << endl;
00192 }
00193 
00194 //---------------------------------------------------------------------------------------------
00195 const std::string Anp::Header::GetBEAMTYPE() const
00196 {  
00197    //
00198    // Return beam type type as std::string
00199    //
00200 
00201    if(!IsValid())
00202    {
00203       cerr << "Header::GetBEAMTYPE - invalid Header" << endl;
00204       return "unknown";
00205    }
00206 
00207    string value;
00208    for(unsigned int i = 0; i < 9; ++i)
00209    {
00210       if(beamtype[i] != ' ') value.push_back(beamtype[i]);
00211    }
00212    
00213    return value;
00214 }
00215 
00216 //---------------------------------------------------------------------------------------------
00217 const std::string Anp::Header::GetDATATYPE() const
00218 {  
00219    //
00220    // Return data type type as std::string
00221    //    for data return run period: run-1, run-2, run-3, etc
00222    //    for simulation return Monte-Carlo release type
00223 
00224    if(!IsValid())
00225    {
00226       cerr << "Header::GetDATATYPE - invalid Header" << endl;
00227       return "unknown";
00228    }
00229 
00230    if(IsData())
00231    {
00232       return std::string("data");
00233    }
00234    else
00235    {
00236       return Anp::Header::GetMCRLTYPE();
00237    }
00238    
00239    return std::string("unknown");
00240 }
00241 
00242 //---------------------------------------------------------------------------------------------
00243 const std::string Anp::Header::GetDETECTOR() const
00244 {
00245    if(!IsValid())
00246    {
00247       cerr << "Header::GetDETECTOR - invalid Header" << endl;
00248       return "unknown";
00249    }
00250 
00251    if(IsNear())
00252    {
00253       return std::string("near");
00254    }
00255    else if(IsFar())
00256    {
00257       return std::string("far");
00258    }
00259 
00260    cerr << "Header::GetDETECTOR - unknown detector type" << endl;
00261 
00262    return std::string("unknown");
00263 }
00264 
00265 //---------------------------------------------------------------------------------------------
00266 const std::string Anp::Header::GetMCRLTYPE() const
00267 {  
00268    //
00269    // Return Monte-Carlo release type as string formatted for batch processing.
00270    //
00271 
00272    if(!IsValid())
00273    {
00274       cerr << "Header::GetMCRLTYPE - invalid Header" << endl;
00275       return "unknown";
00276    }
00277 
00278    if(IsData())
00279    {
00280       return "unknown";
00281    }
00282 
00283    const int rtype = Release();
00284 
00285    const int mcver = ReleaseType::GetMCSubVersion(rtype);
00286    if(ReleaseType::IsDaikon(rtype) && mcver >= 0 && mcver <= 99)
00287    {
00288       stringstream mctype;
00289       mctype << "daikon_" << setw(2) << setfill('0') << mcver;
00290       return std::string(mctype.str());
00291    }
00292 
00293    cerr << "Header::GetMCRLTYPE - unknown Monte-Carlo release" << endl;
00294 
00295    return std::string("unknown");
00296 }
00297 
00298 //---------------------------------------------------------------------------------------------
00299 const std::string Anp::Header::GetRECOTYPE() const
00300 {
00301    //
00302    // Return reconstruction release type as string formatted for batch processing.
00303    //
00304   cout<<" INSIDE get RECOTYPE "<<endl;
00305    if(!IsValid())
00306    {
00307       cerr << "Header::GetRECOTYPE - invalid Header" << endl;
00308       return "unknown";
00309    }
00310    
00311    const int rtype = Release();
00312    
00313    if(ReleaseType::IsCedar(rtype))
00314    {
00315       if(ReleaseType::GetRecoSubVersion(rtype) == 0 ||
00316          ReleaseType::GetRecoSubVersion(rtype) == 1)
00317       {
00318          return std::string("cedar");
00319       }
00320       else if(ReleaseType::GetRecoSubVersion(rtype) == 2)
00321       {
00322          return std::string("cedar_phy");
00323       }
00324       else if(ReleaseType::GetRecoSubVersion(rtype) == 3)
00325       {
00326          return std::string("cedar_phy_bhcurv");
00327       }
00328    }
00329    else if (ReleaseType::IsDogwood(rtype))
00330    {
00331      if(ReleaseType::GetRecoSubVersion(rtype) == 0)
00332        {
00333          return std::string("dogwood0");
00334        }
00335      if(ReleaseType::GetRecoSubVersion(rtype) == 1)
00336        {
00337          return std::string("dogwood1");
00338        }
00339      else{
00340        cerr<<" Header::GetRECOTYPE -- Dogwood with subReco Version "<<
00341          ReleaseType::GetRecoSubVersion(rtype);
00342        return std::string("dogwood1");  
00343      }
00344 
00345    }
00346    
00347    cerr << "Header::GetRECOTYPE - unknown reconstruction release --" << rtype<<"--- "<<endl;
00348    
00349    return "dogwood1";
00350 }
00351 
00352 //---------------------------------------------------------------------------------------------
00353 const std::string Anp::Header::GetRUNCYCLE() const
00354 {
00355    //
00356    // Return reconstruction release type as string formatted for batch processing.
00357    //
00358 
00359    if(!IsValid())
00360    {
00361       cerr << "Header::GetRUNCYCLE - invalid Header" << endl;
00362       return "unknown";
00363    }
00364    
00365    if(IsData())
00366    {
00367       if(RunPeriod() > 0)
00368       {
00369          stringstream rcycle;
00370          rcycle << "run-" << std::setw(1) << RunPeriod();
00371          return std::string(rcycle.str());
00372       }
00373    }
00374    else
00375    {
00376       return std::string("run-0");
00377    }
00378 
00379    cerr << "Header::GetRUNCYCLE - unknown runperiod" << endl;
00380    
00381    return "unknown";
00382 }
00383 
00384 //---------------------------------------------------------------------------------------------
00385 int Anp::Header::SetBeamType(const std::string &value)
00386 {
00387    if(value.size() > 9)
00388    {
00389       cerr << "Header::SetBeamType - truncating input string to first 9 characters: " << value << endl;
00390    }
00391 
00392    for(unsigned int i = 0; i < 9; ++i)
00393    {
00394       if(i < value.size())
00395       {
00396          beamtype[i] =  value[i];
00397       }
00398       else
00399       {
00400          beamtype[i] = ' ';
00401       }
00402    }
00403 
00404    return 9 - int(value.size());
00405 }
00406 
00407 //---------------------------------------------------------------------------------------------
00408 bool Anp::operator==(const Header &lhs, const Header &rhs)
00409 {
00410    if(lhs.Run() != rhs.Run())
00411    {
00412       return false;
00413    }
00414    else if(lhs.SubRun() != rhs.SubRun())
00415    {
00416       return false;
00417    }
00418    else if(lhs.Snarl() != rhs.Snarl())
00419    {
00420       return false;
00421    }
00422 
00423    return true;
00424 }
00425 
00426 //---------------------------------------------------------------------------------------------
00427 bool Anp::operator!=(const Header &lhs, const Header &rhs)
00428 {
00429    return !(lhs == rhs);
00430 }
00431 
00432 //---------------------------------------------------------------------------------------------
00433 std::ostream& Anp::operator<<(std::ostream& o, const Anp::Header &self)
00434 {
00435    self.Print(o);
00436    return o;
00437 }