xmdsintegrate.cc

XMDS is a code generator that integrates equations. You write them down in human readable form in a

};

// ******************************************************************************
unsigned long xmdsIntegrate::lattice() const {
  if(debugFlag) {
    printf("xmdsIntegrate::lattice\n");
  }

  return myLattice;
};

// ******************************************************************************
unsigned long xmdsIntegrate::samples(
				     const unsigned long& index) const {
  if(debugFlag) {
    printf("xmdsIntegrate::KVectorNamesList\n");
  }

  if(index>=mySamplesList.size()) {
    throw xmdsException("Internal range error in xmdsIntegrate::samples");
  }

  list<unsigned long>::const_iterator pULong = mySamplesList.begin();
  for(unsigned long i=0; i<index; i++) {
    pULong++;
  }
  return *pULong;
};

// ******************************************************************************
const list<XMLString>* xmdsIntegrate::KVectorNamesList() const {
  if(debugFlag) {
    printf("xmdsIntegrate::KVectorNamesList\n");
  }

  return &myKVectorNamesList;
};

// ******************************************************************************
bool xmdsIntegrate::constantK() const {
  if(debugFlag) {
    printf("xmdsIntegrate::constantK\n");
  }

  return myConstantK;
};

// ******************************************************************************
bool xmdsIntegrate::noNoises() const {
  if(debugFlag) {
    printf("xmdsIntegrate::noNoises\n");
  }

  return myNonoises;
};

// ******************************************************************************
unsigned long xmdsIntegrate::nKOperators() const {
  if(debugFlag) {
    printf("xmdsIntegrate::nKOperators\n");
  }

  return myKOperatorNamesList.size();
};

// ******************************************************************************
const XMLString* xmdsIntegrate::KOperator(
					  const unsigned long& index) const {
  if(debugFlag) {
    printf("xmdsIntegrate::KOperator\n");
  }

  if(index>=myKOperatorNamesList.size()) {
    throw xmdsException("Internal range error in xmdsIntegrate::KOperator");
  }

  list<XMLString>::const_iterator pXMLString = myKOperatorNamesList.begin();
  for(unsigned long i=0; i<index; i++) {
    pXMLString++;
  }

  return &*pXMLString;
};

// ******************************************************************************
bool xmdsIntegrate::getKOperator(
				 const XMLString& operatorName,
				 unsigned long& index) const {
  if(debugFlag) {
    printf("xmdsField::getVector\n");
  }

  index=0;
  for(list<XMLString>::const_iterator pXMLString = myKOperatorNamesList.begin(); pXMLString != myKOperatorNamesList.end(); pXMLString++) {
    if(*pXMLString==operatorName) {
      return 1;
    }
    index++;
  }

  return 0;
};

// ******************************************************************************
const XMLString* xmdsIntegrate::KOperatorsCode() const {
  if(debugFlag) {
    printf("xmdsIntegrate::KOperatorsCode\n");
  }

  return &myKOperatorsCode;
};

// ******************************************************************************
list<XMLString>* xmdsIntegrate::vectorNamesList() {
  if(debugFlag) {
    printf("xmdsIntegrate::vectorNamesList\n");
  }

  return &myVectorNamesList;
};

// ******************************************************************************
const list<XMLString>* xmdsIntegrate::vectorNamesList() const {
  if(debugFlag) {
    printf("xmdsIntegrate::vectorNamesList\n");
  }

  return &myVectorNamesList;
};

// ******************************************************************************
XMLString* xmdsIntegrate::propagationCode() {
  if(debugFlag) {
    printf("xmdsIntegrate::propagationCode\n");
  }

  return &myPropagationCode;
};

// ******************************************************************************
const XMLString* xmdsIntegrate::propagationCode() const {
  if(debugFlag) {
    printf("xmdsIntegrate::propagationCode\n");
  }

  return &myPropagationCode;
};

// ******************************************************************************
const list<XMLString>* xmdsIntegrate::crossVectorNamesList() const {
  if(debugFlag) {
    printf("xmdsIntegrate::crossVectorNamesList\n");
  }

  return &myCrossVectorNamesList;
};

// ******************************************************************************
unsigned long xmdsIntegrate::crossDimNumber() const {
  if(debugFlag) {
    printf("xmdsIntegrate::crossDimNumber\n");
  }

  return myCrossDimNumber;
};

// ******************************************************************************
const XMLString* xmdsIntegrate::crossPropagationCode() const {
  if(debugFlag) {
    printf("xmdsIntegrate::crossPropagationCode\n");
  }

  return &myCrossPropagationCode;
};

// ******************************************************************************
list<XMLString>* xmdsIntegrate::nonLoopPropagationCodeList() {
  if(debugFlag) {
    printf("xmdsIntegrate::nonLoopPropagationCodeList\n");
  }

  return &myNonLoopPropagationCodeList;
};

// ******************************************************************************
const list<XMLString>* xmdsIntegrate::nonLoopPropagationCodeList() const {
  if(debugFlag) {
    printf("xmdsIntegrate::nonLoopPropagationCodeList\n");
  }

  return &myNonLoopPropagationCodeList;
};

// ******************************************************************************
list<XMLString>* xmdsIntegrate::codeElementList() {
  if(debugFlag) {
    printf("xmdsIntegrate::codeElementList\n");
  }

  return &myCodeElementList;
};

// ******************************************************************************
const list<XMLString>* xmdsIntegrate::codeElementList() const {
  if(debugFlag) {
    printf("xmdsIntegrate::codeElementList\n");
  }

  return &myCodeElementList;
};

// ******************************************************************************
bool xmdsIntegrate::usesKOperators() const {
  if(debugFlag) {
    printf("xmdsIntegrate::usesKOperators\n");
  }

  return (mycoStructList.size()>0);
};

// ******************************************************************************
long unsigned int xmdsIntegrate::numNonLoopPropagation() const {
  if(debugFlag) {
    printf("xmdsIntegrate::numNonLoopPropagation\n");
  }

  return (myNumNonLoopPropagation);
};

// ******************************************************************************
long unsigned int xmdsIntegrate::numIntegrateMomentGroups() const {
  if(debugFlag) {
    printf("xmdsIntegrate::numIntegrateMomentGroups\n");
  }

  return (myNumIntegrateMomentGroups);
};

// ******************************************************************************
list<integrateMomentGroup>* xmdsIntegrate::integrateMomentGroupList() {
  if(debugFlag) {
    printf("xmdsIntegrate::integrateMomentGroupList\n");
  }

  return &myIntegrateMomentGroupList;
};

// ******************************************************************************
const list<integrateMomentGroup>* xmdsIntegrate::integrateMomentGroupList() const {
  if(debugFlag) {
    printf("xmdsIntegrate::integrateMomentGroupList\n");
  }

  return &myIntegrateMomentGroupList;
};

// ******************************************************************************
bool xmdsIntegrate::getcoStruct(
				const unsigned long& componentNumber,
				const coStruct*& thecoStruct) const {
  if(debugFlag) {
    printf("xmdsIntegrate::getcoStruct\n");
  }

  for(list<coStruct>::const_iterator pcoStruct = mycoStructList.begin(); pcoStruct != mycoStructList.end(); pcoStruct++) {
    if(pcoStruct->componentNumber == componentNumber) {
      thecoStruct = &*pcoStruct;
      return 1;
    }
  }
  return 0;
};

// ******************************************************************************
bool xmdsIntegrate::getcoKey(
			     const unsigned long& componentNumber,
			     const unsigned long& operatorNumber,
			     unsigned long& coKey) const {
  if(debugFlag) {
    printf("xmdsIntegrate::getcoPairKey\n");
  }

  const coStruct* thecoStruct;

  if(!getcoStruct(componentNumber,thecoStruct)) {
    return 0;
  }

  list<unsigned long>::const_iterator pULong1 = thecoStruct->operatorNumbersList.begin();
  list<unsigned long>::const_iterator pULong2 = thecoStruct->coKeysList.begin();

  while(pULong1 != thecoStruct->operatorNumbersList.end()) {
    if(*pULong1==operatorNumber) {
      coKey = *pULong2;
      return 1;
    }
    pULong1++;
    pULong2++;
  }

  return 0;
};

// ******************************************************************************
unsigned long xmdsIntegrate::addcoPair(
				       const unsigned long& componentNumber,
				       const unsigned long& operatorNumber) {
  if(debugFlag) {
    printf("xmdsIntegrate::addcoPair\n");
  }

  coStruct* existingcoStruct = 0;

  for(list<coStruct>::iterator pcoStruct = mycoStructList.begin(); pcoStruct != mycoStructList.end(); pcoStruct++) {
    if(pcoStruct->componentNumber == componentNumber) {
      existingcoStruct = &*pcoStruct;
    }
  }

  if(existingcoStruct != 0) {
    existingcoStruct->operatorNumbersList.push_back(operatorNumber);
    existingcoStruct->coKeysList.push_back(myNextcoKey);
  }
  else {
    coStruct nextcoStruct;
    nextcoStruct.componentNumber = componentNumber;
    nextcoStruct.operatorNumbersList.push_back(operatorNumber);
    nextcoStruct.coKeysList.push_back(myNextcoKey);
    mycoStructList.push_back(nextcoStruct);
  }

  myNextcoKey++;
  return myNextcoKey-1;
};

// ******************************************************************************
bool xmdsIntegrate::findNextcoPair(
				   XMLString& operatorName,
				   XMLString& componentName,
				   unsigned long& start,
				   unsigned long& end) const {
  if(debugFlag) {
    printf("xmdsIntegrate::findNextcoPair\n");
  }

  // here we are looking for the next **** operatorName S? '[' S? componentName S? ']' **** production
  // starting from the offset provided

  const char* code=myPropagationCode.c_str();
  end = start;
  unsigned long openBrace;
  unsigned long nameStart;
  unsigned long nameEnd;

  // find next [

  while((code[end] != '[') && (code[end] != 0)) {
    end++;
  }

  if(code[end] == 0) {
    return 0;
  }

  // ok, we found the first [
  openBrace = end;

  // now skip white space
  end++;
  while(XMLChar::isWhiteSpace(code[end]) && (code[end] != 0)) {
    end++;
  }

  if(code[end] == 0) {
    return 0;
  }

  if(!(XMLChar::isLatinLetter(code[end]) | (code[end]=='_'))) {
    return 0;
  }

  nameStart = end;

  end++;
  while((XMLChar::isLatinLetter(code[end]) | XMLChar::isLatinDigit(code[end]) | (code[end]=='_'))&(code[end] != 0)) {
    end++;
  }

  if(code[end] == 0) {
    return 0;
  }

  nameEnd = end;

  //check that we have a ] on the end

  // skip white space
  while(XMLChar::isWhiteSpace(code[end]) && (code[end] != 0)) {
    end++;
  }

  if(code[end] != ']') {
    return 0;
  }

  // ok, we definititely had a nice clean [name]
  end++;

  myPropagationCode.subString(componentName,nameStart,nameEnd);

  // now work backwards to find the operator name
  start=openBrace-1;

  // skip any white space
  while(XMLChar::isWhiteSpace(code[start])&(start>0)) {
    start--;
  }

  if(!(XMLChar::isLatinLetter(code[start]) | XMLChar::isLatinDigit(code[start]) | (code[start]=='_'))) {
    return 0;
  }

  nameEnd=start+1;

  while((XMLChar::isLatinLetter(code[start]) | XMLChar::isLatinDigit(code[start]) | (code[start]=='_'))&(start>0)) {
    start--;
  }

  if(!(XMLChar::isLatinLetter(code[start]) | XMLChar::isLatinDigit(code[start]) | (code[start]=='_'))) {
    start++;
  }

  if(!(XMLChar::isLatinLetter(code[start]) | (code[start]=='_'))) {
    return 0;
  }

  nameStart=start;

  myPropagationCode.subString(operatorName,nameStart,nameEnd);

  return 1;
};

// ******************************************************************************
void xmdsIntegrate::writexSpacePrototype(
					 FILE *const outfile) const {
  if(debugFlag) {
    printf("xmdsIntegrate::writexSpacePrototype\n");
  }

  fprintf(outfile,"void _segment%li_calculate_delta_a(\n",segmentNumber);
  fprintf(outfile,"	const double& _step");
  fprintf(outfile,",\n	const unsigned long cycle");
  if((simulation()->parameters()->stochastic)&&(!myNonoises)) {