Clears the cell list from the hist tape file
   */
{
  histpCells.clear();
  return;
}

int 
PhysicsCards::processCard(const std::string& Line)
  /*!
    Attempt to process a card.
    If comment, store in 'Comments' and insert '0' into 'Cards'
    If card, insert "" into Comments and store in Cards.
    \param Line :: string to process
    \retval :: -ve on fail
    \retval 1 on successful addition of a card
    \retval 0 on null line/comment line
    \todo Trim leading space
  */
{
  ELog::RegMethod RegA("PhysicsCards","processCard");
  if(Line.empty())
    return 0;  

  int expCell(0);
  std::string Comd=Line;
  StrFunc::stripComment(Comd);
  Comd=StrFunc::fullBlock(Comd);

  // Check the first 2 characters for comment
  if(Comd.size()<2 || (isspace(Comd[1]) &&
                       ( tolower(Comd[0])=='c' || Comd[0]=='!'))) 
    return 0;
  
  std::string::size_type pos=Comd.find("mode ");
  if (pos!=std::string::npos)
    {
      std::string item;
      Comd.erase(0,pos+5);
      while(StrFunc::section(Comd,item))
        mode.addElm(item);
      return 1;
    }
  pos=Comd.find("print ");
  if (pos!=std::string::npos)
    {
      printNum.clear();
      std::string Item=Comd.substr(pos+1);
      int pNum;
      while(StrFunc::section(Item,pNum))
        printNum.push_back(pNum);
    }

  
  pos=Comd.find("imp:");
  if (pos!=std::string::npos)
    {
      Comd.erase(0,pos+4);
      ImpCards.push_back(PhysImp("imp"));
      // Ugly hack to get all the a,b,c,d items 
      // since I can't think of the regular expression
      unsigned int index;
      for(index=0;index<Comd.length() && !isspace(Comd[index]);index++)
        if (Comd[index]!=',')
          ImpCards.back().addElm(std::string(1,Comd[index]));
      return 1;
    }

  pos=Comd.find("vol");
  if (pos!=std::string::npos)
    {
      Comd.erase(0,pos+3);
      Volume=PhysImp("vol");
      return 1;
    }

  pos=Comd.find("histp");
  if (pos!=std::string::npos)
    {
      histp=1;
      return 1;
    }

  // This is ignored since we have a prdmp card
  pos=Comd.find("prdmp");    
  if (pos!=std::string::npos)
    {
      return 1;
    }

  pos=Comd.find("nps");
  if (pos!=std::string::npos)
    {
      Comd.erase(0,pos+3);
      if (!StrFunc::convert(Comd,nps))
        nps=800000;
      return 1;
    }

  pos=Comd.find("dbcn");
  if (pos!=std::string::npos)
    {
      long int RS;
      size_t kType;
      double D;
      std::string keyName;
      Comd.erase(0,pos+4);
      if (StrFunc::convert(Comd,RS))
        dbCard->setComp("rndSeed",RS);
      else if (StrFunc::section(Comd,keyName) &&
               (kType=dbCard->keyType(keyName)) )
        {
          if (kType==1 && StrFunc::section(Comd,RS))
            dbCard->setComp(keyName,RS);
          else if (StrFunc::section(Comd,D))
            dbCard->setComp(keyName,RS);
          else
            ELog::EM<<"DBCN ["<<keyName<<"] error  == "
                    <<Comd<<ELog::endErr;
        }
      else
        {
          ELog::EM<<"DBCN [rnd] error  == "<<Comd<<ELog::endErr;
        }
      return 1;
    }

  pos=Comd.find("cut:");
  if (pos!=std::string::npos)
    {
      Comd.erase(0,pos+4);
      PhysCards.push_back(PhysCard("cut"));
      std::string Item;
      if (StrFunc::section(Comd,Item))
        {
          std::vector<std::string> part;
          boost::split(part,Item,boost::is_any_of(","));
          for(std::string& PStr : part)
            boost::trim(PStr,std::locale());
          // ensure no empty particles
          part.erase(
                     remove_if(part.begin(),part.end(),
                               std::bind<bool>(&std::string::empty,
                                               std::placeholders::_1)),
                     part.end());
          
          PhysCard& PC(PhysCards.back());
          for(const std::string& PStr : part)
            PC.addElm(PStr);
          // Strip and process numbers / j
          for(size_t i=0;i<5 && !Comd.empty();i++)
            {
              double d;
              if (StrFunc::section(Comd,d))
                PC.setValue(i,d);
              else if (StrFunc::section(Comd,Item))
                {
                  if (Item.size()==1 && tolower(Item[0]=='j'))
                    PC.setDef(i);
                }
            }
        }
      return 1;
    }
  // ext card
  pos=Comd.find("exp:");
  if (pos!=std::string::npos)
    {
      Comd.erase(0,pos+4);
      // Ugly hack to get all the a,b,c,d items 
      // since I can't think of the regular expression
      size_t index;
      for(index=0;index<Comd.length() && !isspace(Comd[index]);index++)
        if (Comd[index]!=',')
          ExtCard->addElm(std::string(1,Comd[index]));
      // NOW HAVE PROBLEM BECAUSE MULTI-LINE
      expCell=1;
      if (ExtCard->addUnitList(expCell,Comd))
        return 1;
      // drops through to further processing

      expCell=0;
    }

  if (expCell)
    {

      if (ExtCard->addUnitList(expCell,Comd))
        return 1;
      expCell=0;
    }
        
  // Component:
  Basic.push_back(Line);
  return 1;
}

void
PhysicsCards::setEnergyCut(const double E) 
  /*!
    Sets the minimium energy cut
    \param E :: Energy [MeV]
  */
{
  ELog::RegMethod RegA("PhysicsCards","setEnergyCut");

  for(PhysCard& PC : PhysCards)
    PC.setEnergyCut(E);

  sdefCard.cutEnergy(E);
  return;
}

PhysImp&