Anp::RunkNN Class Reference

#include <RunkNN.h>

Inheritance diagram for Anp::RunkNN:
Anp::AlgSnarl Anp::Base

List of all members.

Public Types

typedef std::map< std::string,
AlgThread * > 
ThreadMap

Public Member Functions

 RunkNN ()
virtual ~RunkNN ()
bool Run (Record &record)
void Config (const Registry &reg)
bool Init (const Header &header)
void End (const DataBlock &)

Private Member Functions

bool SaveParts (const Header &header)
bool MakeNames (const Header &header)
void MakeAlg (const Header &header)
void MakePid (const Header &header, const std::string &file, int abase)
void MakeKin (const Header &header, const std::string &file, int abase)
bool Alg (const std::string &name, const Registry &reg, int base, int k1, int k2, int k3, int k4)
bool Add (const std::string &name, int abase)
void AddData (Record &record)
void CutData (Record &record)

Private Attributes

bool fCreateNew
bool fEraseData
bool fMakeAllBeam
bool fMultiThread
bool fPrint
int fMuonKey
int fKinBase
int fPidBase
double fComCut
double fPurCut
double fQoPCut
Registry fConfig
std::string fPath
std::map< std::string, int > fFile
std::string PREFIX
std::string DETECTOR
std::string MCRLTYPE
std::string RECOTYPE
std::string BEAMTYPE
std::string fSelect
ThreadMap fMap

Detailed Description

Definition at line 30 of file RunkNN.h.


Member Typedef Documentation

typedef std::map<std::string, AlgThread *> Anp::RunkNN::ThreadMap

Definition at line 47 of file RunkNN.h.


Constructor & Destructor Documentation

Anp::RunkNN::RunkNN (  ) 

Definition at line 26 of file RunkNN.cxx.

00027    :fCreateNew(false),
00028     fEraseData(true),
00029     fMakeAllBeam(false),
00030     fMultiThread(false),
00031     fPrint(false),
00032     fMuonKey(7000),
00033     fKinBase(1100),
00034     fPidBase(4000),
00035     fComCut(0.90),
00036     fPurCut(0.90),
00037     fQoPCut(-0.005),
00038     fConfig(false),
00039     fPath(""),
00040     fFile(),
00041     PREFIX("prototype"),
00042     DETECTOR(""),
00043     MCRLTYPE(""),
00044     RECOTYPE(""),
00045     BEAMTYPE(""),
00046     fSelect("physics")
00047 {
00048 }

Anp::RunkNN::~RunkNN (  )  [virtual]

Definition at line 51 of file RunkNN.cxx.

00052 {
00053 }


Member Function Documentation

bool Anp::RunkNN::Add ( const std::string &  name,
int  abase 
) [private]

Referenced by MakeNames().

void Anp::RunkNN::AddData ( Record record  )  [private]

Definition at line 668 of file RunkNN.cxx.

References Anp::Record::EventBegIterator(), Anp::Record::EventEndIterator(), fComCut, Lit::Find(), Anp::Record::FindTruth(), fKinBase, fMuonKey, fPurCut, fQoPCut, Anp::Record::GetHeader(), Anp::Header::IsData(), Particle::kNuM, Anp::LongestTrack(), Anp::Record::TrackEnd(), Anp::Record::TruthBeg(), and Anp::Record::TruthEnd().

Referenced by Run().

00669 {
00670    //
00671    // Add temporary data required for kinematic kNN selection
00672    //
00673 
00674    for(EventIterator ievent = record.EventBegIterator(); ievent != record.EventEndIterator(); ++ievent)
00675    {
00676       Event &event = *ievent;
00677 
00678       //
00679       // Find longest reconstructed track
00680       //
00681       TrackIter itrack = Anp::LongestTrack(event, record);
00682 
00683       //
00684       // Event must have a track
00685       //
00686       if(itrack == record.TrackEnd()) continue;      
00687 
00688       //
00689       // Track must pass fit
00690       //
00691       if(!(itrack -> PassFit())) continue;
00692 
00693       //
00694       // Add data keys
00695       //
00696       const double cosn = event.GetNu().CosN();
00697       if(cosn < -1.0 || cosn > +1.0)
00698       {
00699          continue;
00700       }
00701       else
00702       {
00703          event.Add(fKinBase + 10, std::acos(cosn));
00704       }
00705 
00706       event.Add(fKinBase + 4, event.GetNu().PLep());
00707       event.Add(fKinBase + 5, event.GetNu().Q2());
00708       event.Add(fKinBase + 6, event.GetNu().Y());
00709       event.Add(fKinBase + 7, event.GetNu().W2());      
00710       event.Add(fKinBase + 8, event.GetNu().X());      
00711       event.Add(fKinBase + 9, cosn);
00712 
00713       //
00714       // Pass this point only if running on Monte-Carlo with truth records filled
00715       //
00716       if(record.GetHeader().IsData() || record.TruthBeg() == record.TruthEnd()) continue;      
00717 
00718       const TruthIter itruth = record.FindTruth(event);
00719       if(itruth == record.TruthEnd())
00720       {
00721          cerr << "RunkNN::AddData - failed to find Truth" << endl;
00722          continue;
00723       }
00724       
00725       TruthRecoIter ireco = itruth -> Find(event);
00726       if(ireco == itruth -> RecoEnd())
00727       {
00728          cerr << "RunkNN::AddData - failed to find reconstructed truth info" << endl;
00729          continue;
00730       }
00731       else
00732       {
00733          //
00734          // Add purity and completeness variables for debugging
00735          //
00736          event.Add(fKinBase + 2, ireco -> Purity());
00737          event.Add(fKinBase + 3, ireco -> ComplAll());
00738       }
00739       
00740       //
00741       // Use tracks with reconstructed negative curvature
00742       //
00743       if(itrack -> QP() > fQoPCut) continue;
00744 
00745       //
00746       // Use true muon neutrino interactions
00747       //
00748       if(itruth -> Particle() != Particle::kNuM) continue;
00749 
00750       //
00751       // Use true QES, RES or DIS charged current events
00752       //
00753       if(itruth -> Interaction() != 1 || (itruth -> Resonance() != 1001 &&
00754                                           itruth -> Resonance() != 1002 &&
00755                                           itruth -> Resonance() != 1003)) continue;      
00756 
00757       //
00758       // Use well reconstructed events
00759       //
00760       if(ireco -> Purity() < fPurCut || ireco -> ComplAll() < fComCut) continue;
00761       
00762       //
00763       // Find muon truth key which is filled by FillMuonId 
00764       //
00765       if(!(itrack -> KeyExists(fMuonKey)))
00766       {
00767          cerr << "RunkNN::AddData - failed to find muon truth key: " << fMuonKey << endl;
00768          continue;
00769       }
00770 
00771       //
00772       // Reconstucted track must match true muon !!!hardcoded numbers!!!
00773       //      
00774       if(itrack -> DataAt(fMuonKey) < 0.999 || itrack -> DataAt(fMuonKey) > 1.001)
00775       {
00776          continue;
00777       }
00778 
00779       //
00780       // Add resonance code for QES, RES or DIS and use this event for training
00781       //
00782       event.Add(fKinBase + 1, float(itruth -> Resonance() % 1000));
00783    }
00784 }

bool Anp::RunkNN::Alg ( const std::string &  name,
const Registry reg,
int  base,
int  k1,
int  k2,
int  k3,
int  k4 
) [private]
void Anp::RunkNN::Config ( const Registry reg  )  [virtual]

Reimplemented from Anp::AlgSnarl.

Definition at line 171 of file RunkNN.cxx.

References fComCut, fConfig, fCreateNew, fEraseData, fKinBase, fMakeAllBeam, fMultiThread, fMuonKey, fPath, fPidBase, fPrint, fPurCut, fQoPCut, fSelect, Registry::Get(), Registry::KeyExists(), Registry::Merge(), PREFIX, and Anp::Read().

00172 {
00173    //
00174    // Configure self and save Registry for children
00175    //
00176 
00177    Anp::Read(reg, "RunkNNCreateNew",   fCreateNew);
00178    Anp::Read(reg, "RunkNNEraseData",   fEraseData);
00179    Anp::Read(reg, "RunkNNMultiThread", fMultiThread);
00180    Anp::Read(reg, "RunkNNMakeAllBeam", fMakeAllBeam);
00181    Anp::Read(reg, "RunkNNPrint",       fPrint);
00182 
00183    //
00184    // Do not multi-thread when making new knn prototype(s)
00185    //
00186    if(fCreateNew) fMultiThread = false;
00187 
00188    const char *value_path = 0;
00189    if(reg.Get("RunkNNPath", value_path) && value_path)
00190    {
00191       fPath = value_path;
00192    }
00193 
00194    if(!fPath.empty() && fPath[fPath.size()-1] != '/') fPath += "/";
00195 
00196    const char *value_pref = 0;
00197    if(reg.Get("RunkNNPrefix", value_pref) && value_pref)
00198    {
00199       PREFIX = value_pref;
00200    }
00201 
00202    const char *value_selc = 0;
00203    if(reg.Get("RunkNNSelect", value_selc) && value_selc)
00204    {
00205       fSelect = value_selc;
00206    }
00207 
00208    reg.Get("RunkNNComCut", fComCut);
00209    reg.Get("RunkNNPurCut", fPurCut);
00210    reg.Get("RunkNNQoPCut", fQoPCut);
00211    if(fSelect=="QPall") fQoPCut = 10000;
00212    if(reg.KeyExists("PrintConfig"))
00213    {
00214       cout << "RunkNN::Config" << endl
00215            << "   CreateNew = " << fCreateNew << endl
00216            << "   EraseData = " << fEraseData << endl
00217            << "   MultiThread = " << fMultiThread << endl
00218            << "   MuonKey = " << fMuonKey << endl
00219            << "   KinBase = " << fKinBase << endl
00220            << "   PidBase = " << fPidBase << endl
00221            << "   ComCut = " << fComCut << endl
00222            << "   PurCut = " << fPurCut << endl
00223            << "   QoPCut = " << fQoPCut << endl
00224            << "   Print = " << fPrint << endl
00225            << "   Path = " << fPath << endl
00226            << "   PREFIX = " << PREFIX << endl
00227            << "   Select = " << fSelect << endl;
00228    }
00229 
00230    //
00231    // Configure generic Registry for kNN
00232    //
00233    fConfig.Merge(reg);  
00234 }

void Anp::RunkNN::CutData ( Record record  )  [private]

Definition at line 787 of file RunkNN.cxx.

References Anp::Record::EventBegIterator(), Anp::Record::EventEndIterator(), and fKinBase.

Referenced by Run().

00788 {
00789    //
00790    // Erase temporary data required for kinematic kNN selection
00791    //
00792 
00793    vector<short> kvec;
00794    kvec.push_back(fKinBase + 1);
00795    kvec.push_back(fKinBase + 2);
00796    kvec.push_back(fKinBase + 3);
00797    kvec.push_back(fKinBase + 4);
00798    kvec.push_back(fKinBase + 5);
00799    kvec.push_back(fKinBase + 6);
00800    kvec.push_back(fKinBase + 7);
00801    kvec.push_back(fKinBase + 8);
00802    kvec.push_back(fKinBase + 9);
00803    kvec.push_back(fKinBase + 10);
00804 
00805    for(EventIterator ievent = record.EventBegIterator(); ievent != record.EventEndIterator(); ++ievent)
00806    {
00807       ievent -> Erase(std::remove_if(ievent -> DataBegIterator(),
00808                                      ievent -> DataEndIterator(),
00809                                      Anp::PrevDataKey(kvec)), ievent -> DataEndIterator());
00810    }
00811 }

void Anp::RunkNN::End ( const DataBlock block  )  [virtual]

Reimplemented from Anp::AlgSnarl.

Definition at line 258 of file RunkNN.cxx.

References fMap, it, and Munits::second.

00259 {
00260    //
00261    // Destroy AlgThread pointers
00262    //
00263    for(ThreadMap::iterator it = fMap.begin(); it != fMap.end(); ++it)
00264    {
00265       AlgThread *alg = it -> second;
00266       assert(alg && "logic error");
00267 
00268       cout << "   " << it -> first << endl;
00269       alg -> End(block);
00270       delete alg;
00271    }
00272 
00273    fMap.clear();
00274 }

bool Anp::RunkNN::Init ( const Header header  )  [virtual]

Reimplemented from Anp::AlgSnarl.

Definition at line 237 of file RunkNN.cxx.

References fMap, MakeAlg(), MakeNames(), SaveParts(), and Munits::second.

00238 {
00239    //
00240    // Initiliaze self and AlgThread algorithm(s)
00241    //
00242 
00243    assert(fMap.empty() && "logic error - Init() function is probably called twice");
00244 
00245    SaveParts(header);
00246    MakeNames(header);
00247    MakeAlg(header);
00248 
00249    for(ThreadMap::iterator ialg = fMap.begin(); ialg != fMap.end(); ++ialg)
00250    {
00251       ialg -> second -> Init(header);
00252    }
00253 
00254    return true;
00255 }

void Anp::RunkNN::MakeAlg ( const Header header  )  [private]

Definition at line 407 of file RunkNN.cxx.

References fCreateNew, fFile, fPath, infile, MakeKin(), MakePid(), and Munits::second.

Referenced by Init().

00408 {
00409    //
00410    // Make kNN algorithms... lots of hardcoded numbers and decisions...
00411    //
00412 
00413    if(fFile.empty())
00414    {
00415       cerr << "RunkNN::MakeAlg - no kNN file names available" << endl;
00416       return;
00417    }
00418 
00419    for(map<string, int>::const_iterator ifile = fFile.begin(); ifile != fFile.end(); ++ifile)
00420    {
00421       //
00422       // If not creating new kNN algorithm then check if prototype file exists
00423       //
00424       const string file = fPath + ifile -> first;
00425       ifstream infile(file.c_str(), std::ios_base::in);
00426 
00427       if(fCreateNew)
00428       {
00429          if(infile.is_open())
00430          {
00431             cerr << "RunkNN::MakeAlg - file already exists:\n   " << file << endl;
00432             continue;
00433          }
00434       }
00435       else
00436       {
00437          if(!infile.is_open())
00438          {
00439             cerr << "RunkNN::MakeAlg - file does not exist:\n   " << file << endl;
00440             continue;
00441          }
00442       }
00443       
00444       //
00445       // Make FillkNN algorithms for current file and key
00446       //
00447       MakePid(header, ifile -> first, ifile -> second);
00448       MakeKin(header, ifile -> first, ifile -> second);
00449    }
00450 }

void Anp::RunkNN::MakeKin ( const Header header,
const std::string &  file,
int  abase 
) [private]

Referenced by MakeAlg().

bool Anp::RunkNN::MakeNames ( const Header header  )  [private]

Definition at line 303 of file RunkNN.cxx.

References Add(), BEAMTYPE, DETECTOR, fCreateNew, fMakeAllBeam, fSelect, Anp::Header::IsData(), MCRLTYPE, PREFIX, and RECOTYPE.

Referenced by Init().

00304 {
00305    //
00306    // Make file names for kNN algorithms. This function has
00307    // some hardcoded names and decisions.
00308    //
00309    // File name is ideally created as follows:
00310    // 
00311    // PREFIX.DETECTOR.MCRLTYPE.RECOTYPE.BEAMTYPE.root
00312    //
00313    
00314    //
00315    // Case when creating new prototype
00316    //
00317    if(fCreateNew)
00318    {
00319       //
00320       // Can not create prototype from data events
00321       //
00322       if(header.IsData()) return true;
00323 
00324       //
00325       // Create single file, base key is 0 because no keys should be computed
00326       //
00327       return Add(PREFIX+"."+DETECTOR+"."+MCRLTYPE+"."+RECOTYPE+"."+BEAMTYPE+".root", 0);
00328    }
00329 
00330    //
00331    // !!!KLUDGE!!! Only know how to deal with cedar-like releases
00332    //
00333    if(RECOTYPE.find("cedar") == string::npos &&  RECOTYPE.find("dogwood1")==string::npos && RECOTYPE.find("dogwood3"))
00334    {
00335       cerr << "RunkNN::MakeNames - unknown reconstruction release: " << RECOTYPE << endl;
00336       return false;
00337    }
00338 
00339    //
00340    // !!!KLUDGE!!! Use 3 different Monte-Carlo daikon/cedar releases
00341    //
00342    if(fSelect == "physics" && !(RECOTYPE=="dogwood1") && !(RECOTYPE=="dogwood3"))
00343    {
00344      Add(PREFIX + "." + DETECTOR + ".daikon_04.cedar_phy_bhcurv.L010z185i.root", 0);
00345      Add(PREFIX + "." + DETECTOR + ".daikon_00.cedar_phy.L010z185i.root", 1000);
00346    }
00347    else if(fSelect=="physics" && RECOTYPE=="dogwood1")
00348    {
00349      Add(PREFIX + "." + DETECTOR + ".daikon_04.dogwood1.L010z185i.root", 0);
00350    }
00351    else if(fSelect=="physics" && RECOTYPE=="dogwood3")
00352      {// Sorry about this whoever, but dogwood3 implies daikon07  easier to just write it in!!!
00353        Add(PREFIX + "." + DETECTOR + ".daikon_07.dogwood3.L010z185i.root", 0);
00354      }
00355    else if(RECOTYPE == "cedar_phy_bhcurv")
00356    {
00357       Add(PREFIX + "." + DETECTOR + ".daikon_04.cedar_phy_bhcurv.L010z185i.root", 0);
00358    }
00359    else if(RECOTYPE == "cedar_phy")
00360    {
00361       Add(PREFIX + "." + DETECTOR + ".daikon_00.cedar_phy.L010z185i.root", 1000);
00362    }
00363    else if(RECOTYPE == "dogwood1")
00364    {
00365      Add(PREFIX + "." + DETECTOR + ".daikon_04.dogwood1.L010z185i.root", 0);
00366    }
00367    else if(RECOTYPE == "dogwood3")
00368    {
00369      Add(PREFIX + "." + DETECTOR + ".daikon_07.dogwood3.L010z185i.root", 0);
00370    }
00371    else if(RECOTYPE == "dogwood1" && fSelect=="QPall")
00372    {
00373      Add(PREFIX + "." + DETECTOR + ".daikon_04.dogwood1.L010z185i.QPall.root", 1000);
00374    }
00375 
00376 
00377    return true;
00378    
00379    //
00380    // Native beam
00381    //
00382    if(BEAMTYPE != "L010z185i" && (RECOTYPE == "cedar" || 
00383                                   RECOTYPE == "cedar_phy" ||
00384                                   RECOTYPE == "cedar_phy_bhcurv" ||
00385                                   RECOTYPE == "dogwood1"||
00386                                   RECOTYPE == "dogwood3"))
00387    {
00388       Add(PREFIX+"."+DETECTOR+"."+MCRLTYPE+"."+RECOTYPE+"."+BEAMTYPE+".root", 10000);
00389    }
00390 
00391    //
00392    // Many beams combined
00393    //
00394    if(fMakeAllBeam &&  (RECOTYPE == "cedar" || 
00395                         RECOTYPE == "cedar_phy" ||
00396                         RECOTYPE == "cedar_phy_bhcurv" ||
00397                         RECOTYPE == "dogwood1" ||
00398                         RECOTYPE == "dogwood3" ))
00399    {
00400       Add(PREFIX+"."+DETECTOR+"."+MCRLTYPE+"."+RECOTYPE+"."+"ALLBEAM.root", 11000);
00401    }
00402 
00403    return true;
00404 }

void Anp::RunkNN::MakePid ( const Header header,
const std::string &  file,
int  abase 
) [private]

Referenced by MakeAlg().

bool Anp::RunkNN::Run ( Record record  )  [virtual]

Implements Anp::AlgSnarl.

Definition at line 56 of file RunkNN.cxx.

References AddData(), copy(), CutData(), Anp::Record::EventBeg(), Anp::Record::EventBegIterator(), Anp::Record::EventEnd(), Anp::Record::EventEndIterator(), fEraseData, fMap, fMultiThread, fPrint, Anp::Record::GetStdHep(), Anp::Record::GetStrip(), it, Munits::second, Anp::Record::TrackBeg(), Anp::Record::TrackBegIterator(), Anp::Record::TrackEnd(), and Anp::Record::TrackEndIterator().

00057 {
00058    //
00059    // Add data to record, run multiple kNN algorithm, the collect and save knn ouput
00060    //
00061 
00062    if(fPrint)
00063    {
00064       for(EventIter it = record.EventBeg(); it != record.EventEnd(); ++it)
00065       {
00066          cout << "beg: event index " << it -> EventIndex() << endl;
00067          std::copy(it -> DataBeg(), it -> DataEnd(), ostream_iterator<Data>(cout, "\n"));
00068       }
00069       for(TrackIter it = record.TrackBeg(); it != record.TrackEnd(); ++it)
00070       {
00071          cout << "beg: track index " << it -> TrackIndex() << endl;
00072          std::copy(it -> DataBeg(), it -> DataEnd(), ostream_iterator<Data>(cout, "\n"));
00073       }
00074    }
00075 
00076    //
00077    // Add data needed by kinematic kNN selection
00078    //
00079    AddData(record);
00080 
00081    //
00082    // Make lightweight copy of Record for AlgThread(s)
00083    //
00084    Record copy = record;
00085    copy.GetStrip().clear();
00086    copy.GetStdHep().clear();
00087 
00088    //
00089    // First pass, run all kNN algorithms
00090    //
00091    for(ThreadMap::iterator ialg = fMap.begin(); ialg != fMap.end(); ++ialg)
00092    {
00093       ialg -> second -> Run(copy, fMultiThread);
00094    }
00095 
00096    //
00097    // Second pass, collect data
00098    //
00099    for(ThreadMap::iterator ialg = fMap.begin(); ialg != fMap.end(); ++ialg)
00100    {
00101       AlgThread *alg = ialg -> second;
00102 
00103       if(fMultiThread && alg -> Join() != 0)
00104       {
00105          cerr << "RunkNN::Run - thread join function failed" << endl;
00106          continue;
00107       }
00108       
00109       //
00110       // Collect data from current AlgThread algorithm
00111       //
00112       map<int, PrevDataKey> event_map, track_map;
00113 
00114       for(EventIter it = alg -> GetRecord().EventBeg(); it != alg -> GetRecord().EventEnd(); ++it)
00115       {
00116          event_map[it -> EventIndex()] = PrevDataKey(it -> DataBeg(), it -> DataEnd());
00117       }      
00118       for(TrackIter it = alg -> GetRecord().TrackBeg(); it != alg -> GetRecord().TrackEnd(); ++it)
00119       {
00120          track_map[it -> TrackIndex()] = PrevDataKey(it -> DataBeg(), it -> DataEnd());
00121       }    
00122 
00123       //
00124       // Add data from current AlgThread algorithm to events and tracks
00125       //
00126       for(EventIterator it = record.EventBegIterator(); it != record.EventEndIterator(); ++it)
00127       {
00128          event_map[it -> EventIndex()](*it);
00129       }
00130       for(TrackIterator it = record.TrackBegIterator(); it != record.TrackEndIterator(); ++it)
00131       {
00132          track_map[it -> TrackIndex()](*it);
00133       } 
00134    }
00135 
00136    //
00137    // Sort event and track data by keys
00138    //
00139    for(EventIterator it = record.EventBegIterator(); it != record.EventEndIterator(); ++it)
00140    {
00141       std::sort(it -> DataBegIterator(), it -> DataEndIterator());
00142    }
00143    for(TrackIterator it = record.TrackBegIterator(); it != record.TrackEndIterator(); ++it)
00144    {
00145       std::sort(it -> DataBegIterator(), it -> DataEndIterator());
00146    }
00147 
00148    //
00149    // Erase temporary data added by this algorithm
00150    //
00151    if(fEraseData) CutData(record);
00152 
00153    if(fPrint)
00154    {
00155       for(EventIter it = record.EventBeg(); it != record.EventEnd(); ++it)
00156       {
00157          cout << "end: event index " << it -> EventIndex() << endl;
00158          std::copy(it -> DataBeg(), it -> DataEnd(), ostream_iterator<Data>(cout, "\n"));
00159       }
00160       for(TrackIter it = record.TrackBeg(); it != record.TrackEnd(); ++it)
00161       {
00162          cout << "end: track index " << it -> TrackIndex() << endl;
00163          std::copy(it -> DataBeg(), it -> DataEnd(), ostream_iterator<Data>(cout, "\n"));
00164       }
00165    }
00166 
00167    return true;
00168 }

bool Anp::RunkNN::SaveParts ( const Header header  )  [private]

Definition at line 277 of file RunkNN.cxx.

References BEAMTYPE, DETECTOR, fMakeAllBeam, Anp::Header::GetBEAMTYPE(), Anp::Header::GetDETECTOR(), Anp::Header::GetMCRLTYPE(), Anp::Header::GetRECOTYPE(), MCRLTYPE, and RECOTYPE.

Referenced by Init().

00278 {
00279    //
00280    // Collect parts of information for knn prototype file name.
00281    //
00282 
00283    DETECTOR = header.GetDETECTOR();
00284    MCRLTYPE = header.GetMCRLTYPE();
00285    RECOTYPE = header.GetRECOTYPE();
00286    
00287    //
00288    // Do not specify BEAMTYPE if fMakeAllBeam is set to true.
00289    //
00290    if(fMakeAllBeam)
00291    {
00292       BEAMTYPE = "ALLBEAM";
00293    }
00294    else
00295    {
00296       BEAMTYPE = header.GetBEAMTYPE();
00297    }
00298 
00299    return false;
00300 }


Member Data Documentation

std::string Anp::RunkNN::BEAMTYPE [private]

Definition at line 90 of file RunkNN.h.

Referenced by MakeNames(), and SaveParts().

std::string Anp::RunkNN::DETECTOR [private]

Definition at line 87 of file RunkNN.h.

Referenced by MakeNames(), and SaveParts().

double Anp::RunkNN::fComCut [private]

Definition at line 77 of file RunkNN.h.

Referenced by AddData(), and Config().

Definition at line 81 of file RunkNN.h.

Referenced by Config().

bool Anp::RunkNN::fCreateNew [private]

Definition at line 67 of file RunkNN.h.

Referenced by Config(), MakeAlg(), and MakeNames().

bool Anp::RunkNN::fEraseData [private]

Definition at line 68 of file RunkNN.h.

Referenced by Config(), and Run().

std::map<std::string, int> Anp::RunkNN::fFile [private]

Definition at line 84 of file RunkNN.h.

Referenced by MakeAlg().

int Anp::RunkNN::fKinBase [private]

Definition at line 74 of file RunkNN.h.

Referenced by AddData(), Config(), and CutData().

bool Anp::RunkNN::fMakeAllBeam [private]

Definition at line 69 of file RunkNN.h.

Referenced by Config(), MakeNames(), and SaveParts().

Definition at line 93 of file RunkNN.h.

Referenced by End(), Init(), and Run().

bool Anp::RunkNN::fMultiThread [private]

Definition at line 70 of file RunkNN.h.

Referenced by Config(), and Run().

int Anp::RunkNN::fMuonKey [private]

Definition at line 73 of file RunkNN.h.

Referenced by AddData(), and Config().

std::string Anp::RunkNN::fPath [private]

Definition at line 83 of file RunkNN.h.

Referenced by Config(), and MakeAlg().

int Anp::RunkNN::fPidBase [private]

Definition at line 75 of file RunkNN.h.

Referenced by Config().

bool Anp::RunkNN::fPrint [private]

Definition at line 71 of file RunkNN.h.

Referenced by Config(), and Run().

double Anp::RunkNN::fPurCut [private]

Definition at line 78 of file RunkNN.h.

Referenced by AddData(), and Config().

double Anp::RunkNN::fQoPCut [private]

Definition at line 79 of file RunkNN.h.

Referenced by AddData(), and Config().

std::string Anp::RunkNN::fSelect [private]

Definition at line 91 of file RunkNN.h.

Referenced by Config(), and MakeNames().

std::string Anp::RunkNN::MCRLTYPE [private]

Definition at line 88 of file RunkNN.h.

Referenced by MakeNames(), and SaveParts().

std::string Anp::RunkNN::PREFIX [private]

Definition at line 86 of file RunkNN.h.

Referenced by Config(), and MakeNames().

std::string Anp::RunkNN::RECOTYPE [private]

Definition at line 89 of file RunkNN.h.

Referenced by MakeNames(), and SaveParts().


The documentation for this class was generated from the following files:

Generated on 15 Jul 2018 for loon by  doxygen 1.6.1