---

PDT.cxx

Go to the documentation of this file.

//   $Id: PDT.cxx,v 1.2 2000/01/17 23:37:31 burnett Exp $
//
// This file is part of Gismo 2

//
//   implement the PDT class

#include "gismo/PDT.h"


#include "DecayEntry.h"
#include "PDTEntry.h"
#include "AntiPData.h"

#include "gismo/Units.h"
#include "facilities/error.h"

#include <strstream>
#include <iostream>

#include <algorithm> // for find



// ----------------------- PDT implementation ------------------------

void PDT::addDecay(const char* pname, float bf, const char * decayerName,
            const char* child1, const char* child2, const char* child3,
            const char* child4, const char* child5)
{
   PData* primary = lookUp(pname);
        if (primary == 0) return;

   const char *kids[5] = {child1, child2, child3, child4, child5};

   PData *children[5] = { 0, 0, 0, 0, 0};

   for( int nkids=0; nkids<5; nkids++ )
   {    PData* secondary = lookUp(kids[nkids]);
        if( secondary ==0 ) break;
        children[nkids] = secondary;
   }

    DecayEntry* de = new DecayEntry(bf, children);

    // link into list of decays for this particle/anti particle
    PDTEntry* data = primary->theData;
    de->next = data->decayInfo;

    data->sumBR += bf;
    data->decayInfo = de;

    Decayer * dr;
    int found=0;

    // look for the decayer

    for( Decayer_list::iterator dit=decayers.begin();
            dit < decayers.end(); ++dit) {
        dr = *dit;
        if (strcmp(dr->name(),decayerName)==0) {
            found=1;
            break;
        }
    }
    if (!found)   {   // not found: create, add the list

        dr = new Decayer(decayerName);   // define the default
        decayers.push_back(dr);
    }
    de->decayer = dr;

}
PDT::~PDT()
{
    Decayer_list::iterator dit = decayers.begin();
    while( dit != decayers.end() )
        delete *dit++;

    Interactor_list::iterator iit = interactors.begin();
    while( iit != interactors.end() )   
        delete *iit++;

    PData_list::iterator pit = particles.begin();
    while( pit != particles.end() )
        delete *pit++;

}

PData * PDT::getParticleAt(unsigned i)const
{
    return particles[i];
}

unsigned PDT::getIndexOf(PData* look)
{
    return std::find(particles.begin(), particles.end(), look)-particles.begin();
}

unsigned PDT::getIndexOf(long id)
{
    for( PData_list::iterator pit= particles.begin(); pit < particles.end(); ++pit )    {
        PData* pd = *pit;
        if( id == pd->idCode() ) return pit-particles.begin();
    }
    WARNING("PDT: search for id unsuccessful");
    return count();  // sort of an error?
}
void PDT::addDecayer(Decayer* aDecayer)
{

    // if an entry with the same name already exists, set its
    // replacement field

    // look for the decayer
    for( Decayer_list::iterator dit = decayers.begin(); dit<decayers.end(); ++dit){
        Decayer *dr = *dit;
        if (strcmp(dr->name(),aDecayer->name())==0)      {
            dr->replacement = aDecayer;
            break;
        }
    }
    decayers.push_back(aDecayer);
}

void PDT::setInteraction(const char * name)
{
    // Use while defining particle table to specify interaction type

    // first see if interactor with same name already exists

    for( Interactor_list::iterator it=interactors.begin(); it<interactors.end(); ++it){
        Interactor* i = *it;
        if( strcmp(i->name(), name)==0 ) {
            type  = i;
            return;
        }
    }
    // a new interaction: define it with default, so it may be replaced
    // by user later
    addInteractor(new Interactor(name));

}
void PDT::addInteractor(Interactor* anInteractor)
{
    // if an entry with the same name already exists, set its
    // replacement field

    for( Interactor_list::iterator it=interactors.begin(); it<interactors.end(); ++it){
        Interactor* i = *it;
        if( strcmp(i->name(), anInteractor->name())==0 ){
            i->replacement = anInteractor;
            break;
        }
    }
    interactors.push_back(anInteractor);

    // set pointer to be used for subsequent particle definitions
    type = anInteractor;

}

PData* PDT::addParticle(const char* pname, const char* aname,long id,
        int spin,int charge, float mass,float width)
{
    PDTEntry * data = new PDTEntry(id, spin, charge, mass,width);
    PData * pd = new PData(pname, data);
    data->intobject = type;
    particles.push_back(pd);
    particles.push_back(new AntiPData(aname,pd));
    return pd;
}

PData*  PDT::addParticle(const char* pname, long id,
        int spin, int charge, float mass,float width)
{
    PDTEntry * data = new PDTEntry(id,spin,charge,mass,width);
    data->intobject = type;
    PData * pd = new PData(pname,data);
    particles.push_back(pd);
    return pd;
}

PData* PDT::lookUp(const char * name)
{
    if (name == 0)   return 0;
    if (*name=='\0') return 0;

    for(PData_list::iterator pit=particles.begin(); pit<particles.end(); ++pit){
        if( strcmp((*pit)->name(),name)==0 ) return *pit;

        if( strcmp(name,"unknown")==0 )
            return addParticle((char*)name,0L,0,0,0.,0.);

        if( strcmp(name,"decay list")==0 ) {
            printOn(std::cout);
            return 0;
        }
    }
    return 0;
}

PData* PDT::lookUp(long id)const
{
    // look for the particle by Particle Data Group id

    for(PData_list::const_iterator pit=particles.begin(); pit<particles.end(); ++pit){
        if ((*pit)->idCode() == id) return *pit;
    }
    return 0;
}


void PDT::printOn(std::ostream& cout) const
{
    int i;
    cout << '\n'; for (i=0;i<72;i++)cout << '-'; cout<<'\n';

    cout << "                 The GISMO Particle Data Table\n";
    for (i=0;i<72;i++)cout << '-'; cout<<'\n';

    cout << "                                      -------- decays ---------\n";
    cout << "   id  name     mass     width        fraction  type   products";
    cout <<'\n'; for ( i=0;i<72;i++)cout << '-';

    for(PData_list::const_iterator pit=particles.begin(); pit<particles.end(); ++pit){
        (*pit)->printOn(cout);
    }
    cout << '\n'; for ( i=0;i<72;i++)cout << '-';
    cout << '\n';
}

---