ReadCenterFocusParams.cpp

Go to the documentation of this file.

// Achtung: hoellisch aufpassen - du bist hier im Namespace!!




bool getUserHomeDir(std::string & userHomeDir)
{
        userHomeDir=std::string("");
        // getpwent
        //cerr << "uid" << std::getuid()<<  endl;
        struct passwd  * res= getpwuid( getuid() );
        
        if (res)
        {
                userHomeDir=std::string(res->pw_dir);
                std::cerr << "userHomeDir = " << userHomeDir;
                return true;
                //cerr << "user: " << res->pw_name << endl;
        }
        return false;
}







/*
char *getcwd(char *path, int maxchars);
[path is your buffer for storing the directory pathname, maxchars is its size-1. Returns pointer to your buffer]

int chdir(const char *path);
[path is the directory you want to go to.Returns 0 if successful, -1 if error]

*/
using namespace nCenterFocus;
using nCenterFocus::CenterfocusParams;



template <class tParams>
        string composeOutputFileName(string prefix,tParams* params)
        {

                stringstream outputFile_stream;
                outputFile_stream << prefix;
                outputFile_stream << ".tag_" << params->getExperimentTagNoWS();
                outputFile_stream << ".fieldchar_" << params->getFieldCharacteristic();
                outputFile_stream << ".deg_" << params->getPolynomialDegree();
                outputFile_stream << ".eps_" << params->getEpsPrecision();
                outputFile_stream << ".minVanish_" << params->requiredVanishedFocalValuesNum();
                outputFile_stream << ".jacobianRank_" << params->getRequiredFullJacobianMinRank();
                outputFile_stream << ".subJacobianRank_" << params->getRequiredSubJacobianMinRank();
                if ( params->hasVariableCoefficients() )
                        outputFile_stream << ".seed_" << (long)(*(params->getRandomSeedPtr()));
                outputFile_stream << ".m2" ;
                
                string outputFileName ,tmpstr;
                // remove whitespaces:
                while (outputFile_stream >> tmpstr )
                {
                        outputFileName=outputFileName+tmpstr;
                }       
        
                return  outputFileName;
        }



template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::characteristic_ConstString_m("characteristic");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::polynomialDegree_ConstString_m("polynomialDegree");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::reqVanisnedValues_ConstString_m("reqiredVanishedValues");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::maxFocalValues_ConstString_m("maxFocalValues");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::randomTrialsNum_ConstString_m("randomTrialsNum");


template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::requestedLiftPointNum_ConstString_m("numLiftPoints");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::maxLift_ConstString_m("maxLift");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::liftTrials_ConstString_m("liftTrials");


template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::exhaustiveMaxLift_ConstString_m("exhaustiveMaxLift");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::exhaustiveLiftTrials_ConstString_m("exhaustiveLiftTrials");


template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::randomSeed_ConstString_m("randomSeed");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::randomSeedFromSysTime_ConstString_m("randomSeedFromSysTime");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::epsPrecision_ConstString_m("epsPrecision");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::minJacobianRank_ConstString_m("minJacobianRank");
template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::minJacobianSubMatrixRank_ConstString_m("minJacobianSubMatrixRank");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::randomCounterStartValue_ConstString_m("randomCounterStartValue");


template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::useFormula1_ConstString_m("useFormula1");
template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::useFormula2_ConstString_m("useFormula2");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::useFormula23_ConstString_m("useFormula23");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::appendResults_ConstString_m("appendResults");


template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::experimentTag_ConstString_m("experimentTag");


template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::HamiltonianComponentSwitch_ConstString_m("HamiltonianComponentSwitch");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::nonSmoothPointPassFilter_ConstString_m("nonSmoothPointPassFilter");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::experimentTagNoWhiteSpaces_ConstString_m("experimentTagNoWhiteSpaces");


template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::true_ConstString_m("true");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::false_ConstString_m("false");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::showProgress_ConstString_m("showProgress");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::minComponentCodim_ConstString_m("minComponentCodim");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::logExtendedLiftStatistic_ConstString_m("logExtendedLiftStatistic");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::pureSmothnessTest_ConstString_m("pureSmoothnessTest");


 

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::checkpointInterval_ConstString_m("checkpointInterval");


template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::pointFilter_ConstString_m("pointFilter");

template <class TPolynomXY, class TRing >
  const string CenterfocusParams< TPolynomXY, TRing >::pointFilterStrategy_ConstString_m("pointFilterStrategy");





template <class TPolynomXY, class TRing >
 CenterfocusParams< TPolynomXY, TRing >::CenterfocusParams(const int argc, const char * const argv[])
{

        init();
        
        //get inputFileName
        string inputFileName;
        if (argc<2)
        {
                std::cerr << "Please specify an input file or source!"<< endl;
                //inputFileName = string("Eingabe.txt");
                exit(0);
        }
        else
        {
                inputFileName = string((char*)(argv)[1]);
        }


        if (strcmp(argv[1],"+")==0)     //read params from string  (argv[3])
        {
                std::cerr << "+" << std::endl;
                assert(argc==4);
                loadParamListFromString(argv[3]);
        }
        else
        {
                loadParamList(inputFileName);
        }


        

        // setzt auch den parameter. ob es sich um ein Zufallsexperiment handelt.
        assert(  areWellDefined() );


        //initRandomTrialsNum(); // TODO wieso kann man initRandomTrialsNum nur   areWellDefined()  korrekti initialisieren?
        initNonNegativeIntParameter( randomTrialsNum_ConstString_m,     azZufallszahlen_m,      104);
        
        setupOutputFile(argc,argv);

};

template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::setupOutputFile(const int argc, const char * const argv[])
{
        bWriteToCout_m=false;
        if (argc >= 3 && !strcmp(argv[2], "-"))
        {
                cerr <<"copyfmt" << endl;
                os_m.copyfmt( std::cout);
                os_m.clear( std::cout.rdstate() );
                os_m.basic_ios<char>::rdbuf( std::cout.rdbuf() );
                bWriteToCout_m=true;
        }
        else
        {
                
                ifstream inp;

                if (argc < 3)   
                        outputFileName_m = composeOutputFileName("output", this);
                else    
                        outputFileName_m = composeOutputFileName((char*)(argv)[2],this);

                
                
        
                if (bLocking_m)
                {
                        std::string str_UserHomeDir;
                        if ( !getUserHomeDir(str_UserHomeDir) )
                        {
                                std::cerr << "creating lockfile: it was not possible to determine user home directory" << std::endl;
                                exit(0);
                        }
                        std::string str_LockFileName= str_UserHomeDir+std::string("/.centerfocus.lck");
        
                        //int fd = open(lockFileName_m.c_str(), O_RDWR | O_CREAT );
                        //int fd = open("/home/kroeker/.centerfocus.lck" , O_RDWR | O_CREAT,S_IWUSR );

                        int fd = open( str_LockFileName.c_str(), O_RDWR | O_CREAT,S_IWUSR );
                        
                        struct flock lock;
                        
                        lock.l_type = F_WRLCK;
                        lock.l_whence = SEEK_SET;
                        lock.l_start = 0;
                        lock.l_len=0;

                        /* Place a write lock on the file. */
                        int lfd=-1;
                        for (int i=0; i<10; i++)
                        {
                                lfd=fcntl (fd, F_SETLK, &lock);
                                //if (lfd<0 && errno==EEXIST)
                                if (lfd<0  )
                                {
                                        assert(errno!=29);
                                        // the file already exist; another process is 
                                        // holding the lock
                                        usleep(rand()*1000 % 1000000); //  warten
                                }
                                else
                                {       
                                        assert(errno!=29);
                                        std::cerr << "lfd= " << lfd << std::endl;                       
                                        std::cerr << "errno= " << errno << std::endl;   
                                        break;
                                }
                        }

                        
                        //int fd = open( (string(outputFileName_m+".lck")).c_str(), O_RDWR | O_CREAT | O_EXCL);
                        
                        //int fd = open( outputFileName_m.c_str(), O_RDWR | O_CREAT | O_EXCL);
                        if (lfd<0 && (errno==EEXIST || errno==EAGAIN) )
                        {
                        // the file already exist; another process is 
                                // holding the lock
                                cout<<"io is currently locked; try again later";
                                exit(0);
                        }
                        else if (lfd < 0)
                        {
                                // perror() appends a verbal description of the current
                                // errno value after the user-supplied string
                                perror("locking failed for the following reason");
                                exit(0);
                        }
                        else // file successfully locked
                        {
                                inp.open(outputFileName_m.c_str(), ifstream::in);
                
                                if (inp && !bMultipleExperimentsInAFile_m)
                                {
                                        std::cerr << "error: output file '" << outputFileName_m << "' already exists, appending is disabled! " << std::endl;
                                        exit(0);
                                }
                                inp.close();
                                os_m.open(outputFileName_m.c_str(), ios::app);
                                os_m << " ";
                                os_m.flush(); 
                                assert (!os_m.bad() );
                                lock.l_type = F_UNLCK;
                                int lfd2=fcntl (fd, F_SETLK, &lock);
                                if (lfd2<0) 
                                {       
                                        cout<<"unlocking failed " << std::endl;
                                        perror("unlocking failed for the following reason");
                                }
                                assert(lfd2>=0);
                                
                        }
                        assert(fd>0);
                        int cfd=close(fd);
                        assert(cfd==0); 

                }
                else
                {
                                inp.open(outputFileName_m.c_str(), ifstream::in);
                
                                if (inp && !bMultipleExperimentsInAFile_m)
                                {
                                        std::cerr << "error: result file '" << outputFileName_m << "' already exists, appending is disabled! " << std::endl;
                                        exit(0);
                                }
                                inp.close();
                                os_m.open(outputFileName_m.c_str(), ios::app);
                }
        }
}


template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::init()
{
                bWriteToCout_m=false;
        // internal parameters
                bLocking_m=false;
                #ifdef CFLOCKING
                bLocking_m=true;
                #endif
                firstPQ_m       = true;
                braceLevel_m    = 0;
        
                positionInLValue_m      = false;
                parameterNameExpected_m = true;


        // centerfocus options
                checkpointInterval_m=10800;

                bPureSmoothnessTest_m = false;
                bShowProgress_m = false;
                randomCounterStartValue_m = 0;
                bMultipleExperimentsInAFile_m = false;

                benutzeFormel_1_m       = false;
                benutzeFormel_2_m       = false;
                benutzeFormel_23_m = false;
 
                HamiltonianComponentSwitch_m            = 0;
                bNonSmoothPointPassFilter_m=false;

                gradderpolynome_m       = 0;
                bReqVanishedFocalValues_m=1;
                reqSubJacobianMinRank_m=0;
                reqFullJacobianMinRank_m=0;

                minComponentCodim_m = 0;
                /*maxLift_m=2;
                liftTrials_m=1;*/
                maxLift_m=0;
                liftTrials_m=0;

                exhaustiveMaxLift_m    = maxLift_m;
                exhaustiveLiftTrials_m = liftTrials_m;

                pointFilter=NULL;

                requestedLiftPointNum_m=0;

                azZufallszahlen_m        = 0;
                epsPrecision_m          =0;
                randomSeedFromSysTime_m         = false; // Default ZufallsSeed ist angegeben
        
                randomSeed_m = 548; 
        
                // p und q werden in loadParams initialisiert
                infEps_minusP_polynom_m = NULL;
                infEps_Q_polynom_m      = NULL;

                ringEps_m       = NULL;
                bAllConstCoefficientsAreVariables_m=false;

                containsMonomsWithAllCoefficientsCheck_m = 0;
                containsMonomsWithRandomCoefficients_m   = 0; 
                inputFromStd_m=false;

                experimentTag_m = "";
                progressStepWidth_m= 100000;
                lockFileName_m="";

                bLogExtendedLiftStatistic_m = false;
}

//-------------------
template <class TPolynomXY, class TRing >
bool    CenterfocusParams< TPolynomXY, TRing >::isCoefficientVariable(int x_exp, int y_exp, P_or_QPolynom p_or_q ) const
{
        CoeffListEntry entry( p_or_q, x_exp, y_exp );

        if (monomsWithAllCoefficients_m.containsEntry(p_or_q , x_exp,y_exp  ) )
                return true;

        if (monomsWithRandomCoefficients_m.containsEntry(p_or_q , x_exp,y_exp ) )
                return true;

        return false;
}


template <class TPolynomXY, class TRing >
bool    CenterfocusParams< TPolynomXY, TRing >::isCoefficientVariable(const CoeffListEntry & coeffEntry) const
{
        if (monomsWithAllCoefficients_m.containsEntry( coeffEntry ) )
                return true;

        if (monomsWithRandomCoefficients_m.containsEntry( coeffEntry ) )
                return true;
        return false;
}

template <class TPolynomXY, class TRing >
bool    CenterfocusParams< TPolynomXY, TRing >::isRandomVariable(const CoeffListEntry & coeffEntry) const
{
        if (monomsWithRandomCoefficients_m.containsEntry( coeffEntry ) )
                return true;
        return false;
}

template <class TPolynomXY, class TRing >
void  CenterfocusParams< TPolynomXY, TRing >::readMonomGroup(TRing * ring1, TPolynomXY &pol, string &monomGroup, int momomGroupDegree, P_or_QPolynom p_or_q)
{
        stringstream ssMonomGroup(monomGroup);
                #ifdef DEBUG
                cerr << "\t  MonomGroup String:  \n\n"<< monomGroup << endl;    
                #endif
        extractChar('{',ssMonomGroup);

        int y_exp=0;

        for (  int x_exp=momomGroupDegree ;  x_exp>=0;   x_exp--, y_exp++  )
        {
                        #ifdef DEBUG
                                cerr << "\t readMonomGroup: x_exp:  "<< x_exp << endl;
                        #endif

                // extract next unbraced Element on current brace Level (finished by ',' or '}')
                #ifdef DEBUG
                                cerr << "\t readMonomGroup: extractNextData  \n\n"<< endl;
                                cerr << "\t ssMonomGroup: ssMonomGroup  \n\n"<< ssMonomGroup.str() << endl;
                        #endif
                string nextElement=extractNextData(ssMonomGroup);
                        #ifdef DEBUG
                                cerr << "\t readMonomGroup: extractNextData finished! \n\n"<< endl;
                        #endif
                //extract colon
                if ( ssMonomGroup.peek()==',' )
                        extractChar(',',ssMonomGroup);

                if ( isAllMarker(nextElement) ) //='A'
                {
                        #ifdef DEBUG
                                cerr << "\t readMonomGroup: isAllMarker"<< endl;
                        #endif
                        CoeffListEntry * entry= new CoeffListEntry(p_or_q, y_exp, momomGroupDegree);
                        monomsWithAllCoefficients_m.append(entry);
                }
                else if ( isRandomMarker(nextElement) ) //='?'
                {
                        #ifdef DEBUG
                                cerr << "\t readMonomGroup: isRandomMarker"<< endl;
                        #endif
                        CoeffListEntry * entry=new CoeffListEntry(p_or_q, y_exp, momomGroupDegree);
                        monomsWithRandomCoefficients_m.append(entry);
                }

                else  // Monom Coeff='coeff+coeff2*e^1+coeff3*e^3+...'
                {
                
                        #ifdef DEBUG
                                cerr << "\t readMonomGroup: parseNumber"<< endl;
                        #endif
                        typename TRing::ElementType  coeff = parseNumber( ring1, nextElement.c_str(), this->epsPrecision_m);    
                        if (p_or_q==PCoefficient)
                        {
                                pol.setCoeff( x_exp, y_exp, ring1->addInv(coeff));
                        }
                        else
                                pol.setCoeff( x_exp, y_exp, coeff );
                }
        }
        extractChar('}',ssMonomGroup);
        return;
}




template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::updatePolynom(TRing * ring1, TPolynomXY &pol, stringstream &polynomStream, P_or_QPolynom p_or_q)
{
        #ifdef DEBUG
                std::cerr << "updatePolynom" << std::endl;
        #endif
        
        polynomStream >> ws;
        extractChar('{',polynomStream);
//      std::cerr << "extracted" << std::endl;
        int lastMonomDegree=-1;
        int currMonomDegree=0;
        

        int MaxMonomDegree=getMaxMonomDegree( polynomStream.str() );
        pol.setDegree(MaxMonomDegree); // Redimensionierung , man könnte das Polynom auch neu anlegen, vielleicht sogar bessere Variante.

        // erzeuge nun listen mit extrahierten {}
        while (!polynomStream.eof() && polynomStream.peek()=='{')
        {
                #ifdef DEBUG
                std::cerr << "while (polynomStream.peek()=='{')"<< std::endl;
                #endif
                string monomGroup=extractNextBracedData(polynomStream);
                #ifdef DEBUG
                std::cerr << "monomgroup: '" << monomGroup <<"'" <<std::endl;
                #endif
                polynomStream>>ws;
                if ( polynomStream.peek()!='}' )                
                        extractChar(',',polynomStream);
                polynomStream>>ws;
                // get degree of monoms in this grout : is equal to number of elements decreased by 1.
                currMonomDegree=getMonomDegree(monomGroup);

                if ( ( lastMonomDegree==-1 && currMonomDegree==2 ) || lastMonomDegree+1==currMonomDegree )
                        lastMonomDegree=currMonomDegree;
                else
                {
                        throw " P and Q monom coefficient groups must be ordered ascending by degree and starting with monomDegree=2 ";
                }
        //      cerr << "pol.getMaxDegree()" << pol.getMaxDegree() << endl;
        //      cerr << "currMonomDegree" << currMonomDegree << endl;  
                if (pol.getMaxDegree()>= currMonomDegree)
                {
                        //extract monoms and update polynom!
                        #ifdef DEBUG
                        cerr << "readMonomGroup()" <<     endl;
                        #endif
                        readMonomGroup(ring1, pol, monomGroup,  currMonomDegree, p_or_q);
                        #ifdef DEBUG
                        cerr << "readMonomGroup() finished!" <<     endl;
                        #endif
                }
                else
                {
                        throw "Unexpected error: polynom max degree too small " ;
                }
        }
        #ifdef DEBUG
        cerr << "updatePolynom: while() finished!" <<     endl;
        #endif
        polynomStream>>ws;
        extractChar('}',polynomStream);
        polynomStream>>ws;
        #ifdef DEBUG
                std::cerr << "polynomStream! " << polynomStream.str() << std::endl; 
        #endif
        assert(polynomStream.eof());
        #ifdef DEBUG
                std::cerr << "updatePolynom :finished!" << std::endl;
        #endif
}



template <class TPolynomXY, class TRing >
void  CenterfocusParams< TPolynomXY, TRing >::updatePolynoms(stringstream & polynomData, TRing* ring1)
{
        std::string strPolynomData=polynomData.str();
        if (strPolynomData.find("dx")!=std::string::npos || strPolynomData.find("dy")!=std::string::npos)
        {       
                return updatePolynomsFromDifferentialForm(strPolynomData);
        }
        
        //remove Position Markers for Random Monom Coefficients 
        // and remove position markers for monons for which all possible coefficiens has to be tested
                
                monomsWithAllCoefficients_m.clear();
                monomsWithRandomCoefficients_m.clear();
        

        // read Stream part with information about next P,Q polynom pair experiment configuration 
                stringstream pstream;
                stringstream qstream;
                extractStreamFromPQStream(polynomData, PCoefficient, pstream, qstream);

        // update interlan  P,Q polynom pair experiment configuration
                assert(ring1!=NULL);
                assert(infEps_minusP_polynom_m!=NULL);
                assert(infEps_Q_polynom_m!=NULL);
                infEps_minusP_polynom_m->clear();       infEps_Q_polynom_m->clear();
                
                updatePolynom(ring1, *infEps_minusP_polynom_m, pstream,  PCoefficient );        
                updatePolynom(ring1, *infEps_Q_polynom_m,       qstream,  QCoefficient );

                typename TRing::ElementType w;
                infEps_minusP_polynom_m->setCoeff(1,0, ring1->addInv( TRing::ElementType::One) );
                infEps_Q_polynom_m->setCoeff(0,1, TRing::ElementType::One);


                if (monomsWithAllCoefficients_m.isEmpty())      
                        containsMonomsWithAllCoefficientsCheck_m = false;
                else    containsMonomsWithAllCoefficientsCheck_m = true;

                if (monomsWithRandomCoefficients_m.isEmpty())   
                        containsMonomsWithRandomCoefficients_m = 0;  // wird auch als Zahl eingesetzt, ind er Main, daher: initialisieren nur mit 1!
                else    containsMonomsWithRandomCoefficients_m = 1;
        return;
}

template <class TPolynomXY, class TRing >
void    CenterfocusParams< TPolynomXY, TRing >::updatePolynomsFromDifferentialForm(string  differentialFormString)
{

        differentialFormString=eatWS(differentialFormString);
        std::stringstream sstre(differentialFormString);
        extractChar('{', sstre);
        sstre >> differentialFormString  ;
        differentialFormString=differentialFormString.substr(0,differentialFormString.find("}"));
        //differentialFormString=differentialFormString.substr()
        #ifdef DEBUG
        std::cerr << "differentialFormString=" << differentialFormString;
        #endif

        typedef         fieldScalar< int >      localCoeffType  ;

        typedef          polynomXY< localCoeffType,  dynamicPolynomdefsNoShift >         localPolynomXY_Type;

        //typedef       xyMonom<localCoeffType>         xyMonomType;


        //DifferentialFormTermParser dftp;

        
        //xyOneForm<localPolynomXY_Type> oneForm= dftp.parse< localPolynomXY_Type >(differentialFormString );
        xyOneForm<localPolynomXY_Type> oneForm = xyOneForm<localPolynomXY_Type>(differentialFormString);
        
        localPolynomXY_Type  PPolynom = oneForm.getDxFormPart();
        localPolynomXY_Type  QPolynom = oneForm.getDyFormPart();

        assert(PPolynom.getDegree()<= getPolynomialDegree() );
        assert(QPolynom.getDegree()<= getPolynomialDegree() );

        /*
        // test, ob es sich um eine Poincare Differentialform handelt.
                assert( ringEps_m->ConvertScalar(PPolynom.getCoeff(0,0))==0 );
                assert( ringEps_m->ConvertScalar(PPolynom.getCoeff(1,0))==1 );
                assert( ringEps_m->ConvertScalar(PPolynom.getCoeff(0,1))==0 );
        
                assert( ringEps_m->ConvertScalar(QPolynom.getCoeff(0,0))==0 );
                assert( ringEps_m->ConvertScalar(QPolynom.getCoeff(1,0))==0 );
                assert( ringEps_m->ConvertScalar(QPolynom.getCoeff(0,1))==1 );

        //      QPolynom.setCoeff(0,1,0);
        //      PPolynom.setCoeff(1,0,0);
        */

        // Jetzt: Differentialform konvertieren.

        PolynomialRing<TPolynomXY,TRing > pr (*ringEps_m);

        pr.convertInPlace(PPolynom);
        pr.convertInPlace(QPolynom);

        #ifdef DEBUG
                std::cerr << "PPolynom = " <<  PPolynom << std::endl;
                
                std::cerr  << "QPolynom = " <<  QPolynom << std::endl;
        #endif

        TPolynomXY      tmpPPolynom( getPolynomialDegree() );

        pr.copyPolynomWithGivenEpsPrecision(PPolynom, tmpPPolynom, 0);

        *infEps_minusP_polynom_m        =pr.addInv(tmpPPolynom);

        //pr.copyPolynomWithGivenEpsPrecision(tmpPPolynom, *infEps_minusP_polynom_m, 0);
        pr.copyPolynomWithGivenEpsPrecision(QPolynom, *infEps_Q_polynom_m, 0);

        #ifdef DEBUG
                std::cerr << "infEps_minusP_polynom_m = " << *infEps_minusP_polynom_m << std::endl;
                
                std::cerr  << "infEps_Q_polynom_m = " << *infEps_Q_polynom_m << std::endl << std::endl;
        #endif
        
}




template <class TPolynomXY, class TRing >
bool CenterfocusParams< TPolynomXY, TRing >::readNextPolynoms()
{
        #ifdef DEBUG
                std::cerr << std::endl << std::endl << "readNextPolynoms: " << std::endl;
        #endif
        if (!positionInLValue_m)
        {
                try 
                {
                        gotoLParamValue(*inputFile_m);
                        braceLevel_m=0;
                }
                catch(const char* str)  {
                        std::cerr << "error: " << str << "\n";
                        return false;
                }
                positionInLValue_m=true;
                #ifdef DEBUG
                        std::cerr << "positionInLValue_m=true; " << std::endl;
                #endif
        }
        else{
                #ifdef DEBUG
                        std::cerr << "  positionInLValue_m=true; " << std::endl;
                #endif
        }
        try 
        {
                stringstream polynomData;
                #ifdef DEBUG
                        std::cerr << "braceLevel_m " << braceLevel_m << std::endl;
                #endif
                seekToBraceLevel(*inputFile_m,braceLevel_m,1);

                char a;
                stripComments(*inputFile_m);
        
                a=inputFile_m->peek();
                if (a=='}')
                {
                        // Ende erreicht 
                        extractChar('}', *inputFile_m);
                        stripComments(*inputFile_m);
                        extractChar(';', *inputFile_m);
                        return false;
                }

                if (firstPQ_m)
                {
                        #ifdef DEBUG
                                std::cerr << "firstPQ_m" << std::endl;
                        #endif
                        
                        stripComments(*inputFile_m);
                        extractChar('{', *inputFile_m);
                        stripComments(*inputFile_m);
                        braceLevel_m++;
                        firstPQ_m=false;
                        // insttead seekToBraceLevel2: if fist pq then expecting '{' or '}' else expecting ',{' or '}'
                }
                else // if we have not first polynome and bracelevel is 1 (     seekToBraceLevel(inp,1);), following chars are expected:
                {
                        #ifdef DEBUG
                                std::cerr << "!firstPQ_m" << std::endl;
                        #endif
                        stripComments(*inputFile_m);
                        extractChar(',', *inputFile_m); 
                        stripComments(*inputFile_m);
                        extractChar('{', *inputFile_m);
                        stripComments(*inputFile_m);
                        braceLevel_m++;
                }

                readNextPQPolynomStream(*inputFile_m,polynomData, braceLevel_m);
                #ifdef DEBUG
                        std::cerr << "readNextPQPolynomStream FINISHED! " << std::endl;
                        std::cerr << "braceLevel_m : " << braceLevel_m << std::endl;
                #endif
                updatePolynoms(polynomData, ringEps_m );


                pointID_m=-1;

                stripComments(*inputFile_m);
                a=inputFile_m->peek();

                
                if (a==',')
                {
                        stringstream pointID;
                        extractChar(',', *inputFile_m);
                        stripComments(*inputFile_m);

                        *inputFile_m >> pointID_m;
                        // extrahiere PointID   
                        #ifdef DEBUG
                                std::cerr << "pointid " << pointid << std::endl;
                        #endif
                }

                return true;
        }
        catch(const char* str)  {
                        
                        std::cerr << "Format error in polynom input data (L={...};): " << str << "\n";
                        std::cerr << str << "\n";
                        return false;
                }
}


/* Entwurf:
void CenterfocusParams< TPolynomXY, TRing >::checkCharacteristicWellDefined()
{
        if (fieldCharacteristic_m<2) 
        {
                std::cerr << "characteristic has to be prime and positive!" << std::endl;
                throw("characteristic has to be prime and positive!");
        }
}*/

template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::initFieldCharacteristic()
{
        try
        {
                fieldCharacteristic_m = 0;

                Parameter & p = paramList_m->getParameterRefByName( characteristic_ConstString_m );
                assert ( & p != NULL);
                p.markUsed();
                p.setPrintOrder(10);

                fieldCharacteristic_m = atoi( p.getValueAsString().c_str() );
                if (fieldCharacteristic_m<2) 
                {
                        std::cerr << "characteristic has to be prime and positive!" << std::endl;
                        throw("characteristic has to be prime and positive!");
                }
        }
        catch(char* str)
        {
                std::cerr << "Format error in characteristic input data ("<< characteristic_ConstString_m <<" ={...};): " << str << "\n";
                exit( 0);
        }
}





template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::initPolynomialDegree()
{
        assert( paramList_m->paramExists(polynomialDegree_ConstString_m) );

        Parameter & grad = paramList_m->getParameterRefByName(polynomialDegree_ConstString_m);
        try
        {
                
                assert ( & grad  != NULL );
                grad.markUsed();
                grad.setPrintOrder(40);
                //paramList_m->getParameterValueByName("grad");
                gradderpolynome_m = atoi( grad.getValueAsString().c_str() );
                if (gradderpolynome_m <2) 
                {
                        std::cerr << "polynomial degree must be greater than 1 !" << std::endl;
                        throw("polynomial degree must be greater than 1 !");
                }
        }
        catch(const char* str)
        {
                std::cerr << " error: " << str << "\n";
                std::cerr << " polynomial degree" << grad.getName() << " interpreted as = " << gradderpolynome_m << "\n";
                exit( 0);
        }
}


 


 


template <class TPolynomXY, class TRing >
template <class TInternParameter>
bool  CenterfocusParams< TPolynomXY, TRing >::initNonNegativeIntParameter(string name, TInternParameter & internParameter, int printOrder)
{

        if ( paramList_m->paramExists(name) )
        {
                Parameter & param = paramList_m->getParameterRefByName(name);
                {

                        try{
                                param.setPrintOrder(printOrder);
                                stringstream ss ;
                                ss << param.getValueAsString();
                                TInternParameter parsedInt=0;
                                while (ss >>parsedInt);
                                assert(parsedInt>=0);
                                internParameter=parsedInt;
                        
                
                        }catch(...)
                        {
                                std::cerr << name << " initialisation error: parameter"<< name << " has wrong format. Possible values are positive integers  " << std::endl;
                                exit(0);
                        }
                }
        }
        stringstream    rs;
        rs<<  internParameter;
        
        if (!paramList_m->paramExists( name ))
        {
                paramList_m->addDefaultParameter( name ,  rs.str().c_str() );
        }
        else 
                paramList_m->setParameterValue( name ,  rs.str().c_str() );

        Parameter & param = paramList_m->getParameterRefByName(name);
        param.markUsed();
        return true;
}

template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::initRandomSeed()
{

        initBoolParameter( randomSeedFromSysTime_ConstString_m , randomSeedFromSysTime_m, 130);

        if ( randomSeedFromSysTime_m) 
        {
                time_t tt;

                time(&tt);

                randomSeed_m = (tt);

                randomSeed_m += getpid();

                stringstream gss ;
                gss << randomSeed_m;
        
                if (! paramList_m->paramExists( randomSeed_ConstString_m ) )
                {
                        paramList_m->addDefaultParameter(randomSeed_ConstString_m, gss.str().c_str() );
                }
                Parameter & randomSeed = paramList_m->getParameterRefByName( randomSeed_ConstString_m );
                //assert ( & randomSeed  != NULL );
                randomSeed.setValue( gss.str().c_str() );
                randomSeed.markUsed();
                randomSeed.setPrintOrder(120);
        }
        else
        {
                try
                {
                        if (! paramList_m->paramExists( randomSeed_ConstString_m ) )
                        {
                                stringstream gss ;
                                gss << randomSeed_m;
                                paramList_m->addDefaultParameter(randomSeed_ConstString_m, gss.str().c_str() );
                        }

                        Parameter & randomSeed = paramList_m->getParameterRefByName( randomSeed_ConstString_m );
                        stringstream ss ;
                        ss << randomSeed.getValueAsString();
                        while (ss >>randomSeed_m);
                        assert(ss.eof());
                        
                        randomSeed.markUsed();
                        randomSeed.setPrintOrder(120);
                }
                catch(const char* str)
                {
                        std::cerr << "random seed initialisation error: " << str << "\n";
                        exit(0);
                }

        }
        stringstream    rs;
        rs<<  randomSeed_m;
        
        if (!paramList_m->paramExists( randomSeed_ConstString_m ))
        {
                paramList_m->addDefaultParameter( randomSeed_ConstString_m ,  rs.str().c_str() );
        }
        else 
                paramList_m->setParameterValue( randomSeed_ConstString_m ,  rs.str().c_str() );

}


template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::checkParameters() const
{
        assert(         (benutzeFormel_23_m   && ! benutzeFormel_2_m) || 
                        (!benutzeFormel_23_m  &&   benutzeFormel_2_m) ||
                         (!benutzeFormel_23_m && ! benutzeFormel_2_m) 
                );
}

/*
template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::initLocking()  
{
        if (paramList_m->paramExists (lockFileName_ConstString_m))
        {
                bLocking_m = true;

                Parameter & pLockFileName = paramList_m->getParameterRefByName( lockFileName_ConstString_m );
                stringstream fnamestream;

                lockFileName_m="";
                fnamestream << pExperimentTag.getValueAsString();
        
                extractChar('\"',fnamestream);
                char ch;
                while (!fnamestream.eof() && !fnamestream.fail() )
                {
                        fnamestream  >> ch;
                        // >31: Steuerzeichen filtern
                        if (!fnamestream.eof()  )
                        {
                                //cerr << std::endl << "ch =  " << ch << endl;
                                lockFileName_m+=ch;
                        }
                        //else
                        //      experimentTag_m+='\0';
                }       
                assert(experimentTag_m[experimentTag_m.size()-1]=='\"');
                
                lockFileName_m=lockFileName_m.substr(0,lockFileName_m.size()-1);
                lockFileName_m=trim(experimentTag_m);
                pLockFileName.markUsed();
                pLockFileName.setPrintOrder(160);
        }
}
*/
 

template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::initHamiltonianComponentSwitch()  
{

        if (paramList_m->paramExists(HamiltonianComponentSwitch_ConstString_m) )
        {
                try
                {
                        Parameter & hamiltonianSwitchParam = paramList_m->getParameterRefByName( HamiltonianComponentSwitch_ConstString_m );
                        stringstream ss ;
                        ss << hamiltonianSwitchParam.getValueAsString();
                        while (ss >>HamiltonianComponentSwitch_m);
                        assert( ss.eof() );
                        hamiltonianSwitchParam.markUsed();
                        hamiltonianSwitchParam.setPrintOrder(122);
                        assert(HamiltonianComponentSwitch_m == -1 || HamiltonianComponentSwitch_m==0 || HamiltonianComponentSwitch_m==1 );
                }
                catch(const char* str)
                {
                        std::cerr << "HamiltonianComponentSwitch initialisation error: " << str << "\n";
                        exit(0);
                }
        }
        stringstream    rs;
        rs<<  HamiltonianComponentSwitch_m;
        
        if (!paramList_m->paramExists( HamiltonianComponentSwitch_ConstString_m ))
        {
                paramList_m->addDefaultParameter( HamiltonianComponentSwitch_ConstString_m ,  rs.str().c_str() );
        }
        else 
                paramList_m->setParameterValue( HamiltonianComponentSwitch_ConstString_m ,  rs.str().c_str() );
}

template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::initPointFilter()  
{
        CFilterStrategy filterStrategy(CFilterStrategy::CF_FILTER_RANDOM_START);

        if (paramList_m->paramExists(pointFilter_ConstString_m) )
        {
                try
                {
                
                        Parameter & pointFilterParam = paramList_m->getParameterRefByName( pointFilter_ConstString_m );
                        if (paramList_m->paramExists(pointFilterStrategy_ConstString_m) )
                        {
                                Parameter & pointFilterStrategyParam = paramList_m->getParameterRefByName( pointFilterStrategy_ConstString_m );
                                //strategy = createFilterStrategyFromString(pointFilterStrategyParam.getValueAsString() );

                                filterStrategy= CFilterStrategy(pointFilterStrategyParam.getValueAsString() );
                                pointFilterStrategyParam.markUsed();
                                pointFilterStrategyParam.setPrintOrder(122);
                        
                        }

                        std::string str1("");
                        std::string str2("");
                        stringstream ss( pointFilterParam.getValueAsString() );
                        stringstream ss2;
                        
                        while(  ss >> std::ws >>str1)
                        {
                                str2+=str1;
                        }
                        
                        
                        pointFilter     = new CFPointFilter( str2, filterStrategy, pointFilter_ConstString_m );
                        
                        pointFilterParam.markUsed();
                        pointFilterParam.setPrintOrder(122);

                        if (!paramList_m->paramExists( pointFilterStrategy_ConstString_m ))
                        {
                                paramList_m->addDefaultParameter( pointFilterStrategy_ConstString_m , filterStrategy.getValueAsString().c_str() );
                        }
                }
                catch(const char* str)
                {
                        std::cerr << "pointFilter initialisation error: " << str << "\n";
                        exit(0);
                }
        }
        else
        {
                        pointFilter     = new CFPointFilter( filterStrategy, pointFilter_ConstString_m );
        }
        assert(pointFilter);

}


template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::initExperimentTag()  
{
        if (paramList_m->paramExists (experimentTag_ConstString_m))
        {
                Parameter & pExperimentTag = paramList_m->getParameterRefByName( experimentTag_ConstString_m );
                stringstream tagstream;

                experimentTag_m="";
                tagstream << pExperimentTag.getValueAsString();
        
                extractChar('\"',tagstream);
                char ch;
                while (!tagstream.eof() && !tagstream.fail() )
                {
                        tagstream  >> ch;
                        // >31: Steuerzeichen filtern
                        if (!tagstream.eof() && !tagstream.fail() && ch>31)
                        {
                                //cerr << std::endl << "ch =  " << ch << endl;
                                experimentTag_m+=ch;
                        }
                        //else
                        //      experimentTag_m+='\0';
                }       
                assert(experimentTag_m[experimentTag_m.size()-1]=='\"');
                
                experimentTag_m=experimentTag_m.substr(0,experimentTag_m.size()-1);
                experimentTag_m=trim(experimentTag_m);
                experimentTagNoWS_m=experimentTag_m;
                paramList_m->addParameter( experimentTagNoWhiteSpaces_ConstString_m,  experimentTag_m.c_str() );
                experimentTag_m='\"'+experimentTag_m+'\"';
                paramList_m->setParameterValue( experimentTag_ConstString_m ,  experimentTag_m.c_str() );

                pExperimentTag.markUsed();
                pExperimentTag.setPrintOrder(1);
        }
        else
        {
                paramList_m->addDefaultParameter( experimentTag_ConstString_m ,  string("\"\"") );
        }
}
 

template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::convertStringParamsToOptions()
{

        assert( paramList_m!=NULL );


        this->initFieldCharacteristic();

        maxFocalValuesToCompute_m = getMaxComputableFocalValues();
        initNonNegativeIntParameter( maxFocalValues_ConstString_m,      maxFocalValuesToCompute_m,      110);

        initNonNegativeIntParameter( reqVanisnedValues_ConstString_m,   bReqVanishedFocalValues_m,      110);



        this->initPolynomialDegree();

        initNonNegativeIntParameter( epsPrecision_ConstString_m,        epsPrecision_m, 110);


        if (paramList_m->paramExists ( minJacobianRank_ConstString_m ) )
        {
                try{
                        Parameter & minJacobianMatrixRank = paramList_m->getParameterRefByName( minJacobianRank_ConstString_m );
                        minJacobianMatrixRank.markUsed();
                        minJacobianMatrixRank.setPrintOrder(80);
                        reqFullJacobianMinRank_m = atoi( minJacobianMatrixRank.getValueAsString().c_str() );
                        assert(reqFullJacobianMinRank_m>=0);
                }
                catch(...)
                {
                        cerr << "error: parsing parameter 'minJacobianMatrixRank' failed" ;
                        exit(0);
                         
                }
        }
        else
        {
                reqFullJacobianMinRank_m=0;
                stringstream ss ;
                ss << reqFullJacobianMinRank_m;
                paramList_m->addDefaultParameter( minJacobianRank_ConstString_m ,  ss.str().c_str() );
        }
        if (paramList_m->paramExists ( minJacobianSubMatrixRank_ConstString_m ) )
        {
                try{
                        Parameter & minSubJacobianMatrixRank = paramList_m->getParameterRefByName( minJacobianSubMatrixRank_ConstString_m );
        
                        minSubJacobianMatrixRank.markUsed();
                        minSubJacobianMatrixRank.setPrintOrder(81);
                        reqSubJacobianMinRank_m = atoi( minSubJacobianMatrixRank.getValueAsString().c_str() );
                        assert(reqSubJacobianMinRank_m>=0);
                }       
                catch(...)
                { 
                        reqSubJacobianMinRank_m = 0;
                        cerr << "error: parsing parameter 'minJacobianSubMatrixRank' failed" ;
                        exit(0);
                                
                }
        }
        else
        {
                reqSubJacobianMinRank_m=0;
                stringstream ss ;
                ss << reqSubJacobianMinRank_m;
                paramList_m->addDefaultParameter( minJacobianSubMatrixRank_ConstString_m ,  ss.str().c_str() );
        }

        //maxDegree = maxFocalValuesToCompute_m *2 + 3;

//g vgradderpolynome muss initialisiert sein!
        infEps_minusP_polynom_m = new TPolynomXY(gradderpolynome_m);
        infEps_Q_polynom_m       = new TPolynomXY(gradderpolynome_m);

        //ring vor initHasVariableCoefficients()
        ringEps_m = new TRing(fieldCharacteristic_m, epsPrecision_m );
        this->initHasVariableCoefficients();
        //initHasVariableCoefficients vor randomTrialsNum
        this->initRandomSeed();



        initNonNegativeIntParameter( checkpointInterval_ConstString_m,  checkpointInterval_m,   104);

        initNonNegativeIntParameter( randomCounterStartValue_ConstString_m,     randomCounterStartValue_m,      104);
 
        initNonNegativeIntParameter( randomTrialsNum_ConstString_m,     azZufallszahlen_m,      104);
         


         
 

        initBoolParameter( pureSmothnessTest_ConstString_m , bPureSmoothnessTest_m, 130);

        initBoolParameter( useFormula1_ConstString_m , benutzeFormel_1_m, 140);
        initBoolParameter( useFormula2_ConstString_m , benutzeFormel_2_m, 150);
        
        initBoolParameter( showProgress_ConstString_m , bShowProgress_m, 171);


        initBoolParameter( useFormula23_ConstString_m , benutzeFormel_23_m, 155);

        
          
        initBoolParameter( appendResults_ConstString_m , bMultipleExperimentsInAFile_m, 170);


        initNonNegativeIntParameter( minComponentCodim_ConstString_m,   minComponentCodim_m,    110);
        initNonNegativeIntParameter( maxLift_ConstString_m,                     maxLift_m,                      111);
        initNonNegativeIntParameter( liftTrials_ConstString_m,          liftTrials_m,           112);


        if ( !paramList_m->paramExists(exhaustiveMaxLift_ConstString_m) )
                exhaustiveMaxLift_m=maxLift_m;
        initNonNegativeIntParameter( exhaustiveMaxLift_ConstString_m,   exhaustiveMaxLift_m,    113 );
         

        if (! paramList_m->paramExists(exhaustiveLiftTrials_ConstString_m) )
                exhaustiveLiftTrials_m=liftTrials_m;
        initNonNegativeIntParameter( exhaustiveLiftTrials_ConstString_m,        exhaustiveLiftTrials_m, 114 );
        
        initNonNegativeIntParameter( requestedLiftPointNum_ConstString_m, requestedLiftPointNum_m,115 );

        initExperimentTag();

        initPointFilter();

        initCoeffVariablesOrder();
        
        //initLocking();

        initHamiltonianComponentSwitch();

        initBoolParameter( nonSmoothPointPassFilter_ConstString_m , bNonSmoothPointPassFilter_m, 170);

        initBoolParameter( logExtendedLiftStatistic_ConstString_m , bLogExtendedLiftStatistic_m, 170);
}




template <class TPolynomXY, class TRing >
bool  CenterfocusParams< TPolynomXY, TRing >::initBoolParameter(string name, bool & internParameter, int printOrder)
{

        if ( paramList_m->paramExists(name) )
        {
                Parameter & param = paramList_m->getParameterRefByName(name);
                {

                        param.setPrintOrder(printOrder);
                        if ( param.getValueAsString().compare(true_ConstString_m) == 0) 
                        {
                                internParameter = true;
                                param.markUsed();
                                //paramList_m->markUsed(name);
                                return true;
                        }
        
                        else    if  ( param.getValueAsString().compare(false_ConstString_m) == 0) 
                        {
                                internParameter = false;
                                param.markUsed();
                                //paramList_m->markUsed(name);
                                return true;
                        }
                        else
                        {
                                std::cerr << name << " initialisation error: wrong format; possible values only 'true' and 'false'  " << std::endl;
                                exit(0);
                        }
                }
        }
        else
        {
                if (internParameter)
                        paramList_m->addDefaultParameter(name,true_ConstString_m);
                else
                        paramList_m->addDefaultParameter(name,false_ConstString_m);
        }
        return false;
}

/*
template <class TPolynomXY, class TRing >
void    CenterfocusParams< TPolynomXY, TRing >::loadParamListFromCin(const char * inputParameters)
{
        istringstream * ss = new istringstream( string(inputParameters),istringstream::in);
        inputFile_m=ss;
        
        loadParamList(*inputFile_m);
}*/


template <class TPolynomXY, class TRing >
void    CenterfocusParams< TPolynomXY, TRing >::loadParamListFromString(const char * inputParameters)
{
        istringstream * ss = new istringstream( string(inputParameters),istringstream::in);
        inputFile_m=ss;
        //inputFile_m=ss;
        
        loadParamList(*inputFile_m);
        checkParameters();
}


template <class TPolynomXY, class TRing >
void    CenterfocusParams< TPolynomXY, TRing >::loadParamList(string inputFileName)
{
/* TODO: verschiebe das nach main   - wieso ? die main ist so schon zu gross. Wenn überhaupt, dann ein besseres Design überlegen (j.k)*/
        if (inputFileName.compare("-")==0)
        {
                inputFromStd_m=true;
                //inputFile_m= &std::cin;
                string tmpString ;
                string inputFileString="";
                while (  std::getline(std::cin, tmpString)   )
                {
                        inputFileString=inputFileString+"\n"+ tmpString;
                }
                istringstream * ss = new istringstream( string(inputFileString),istringstream::in);
                inputFile_m=ss;
                loadParamList(*inputFile_m);
        }

        else
        {
                inputFromStd_m=false;
                inputFile_m = new ifstream(inputFileName.c_str(), ios::in);
                loadParamList(*inputFile_m);
        }
        checkParameters();
}


template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::loadParamList(istream &fileInStream_)
{
        std::cerr << "loadParams" << std::endl;
        paramList_m = new Parameterlist;
        string paramname="";
        parameterNameExpected_m=true;

        fileInStream_.clear();

        char a;
        stringstream cache;
        bool macaulayCode=false;
        
        if (fileInStream_)
        {
                while ( !fileInStream_.eof()  ) //&& ! paramname.compare("EOF")==0 )
                {
                        if ( macaulayCode )  // jump over macaulayCode
                        {
                                fileInStream_ >> std::noskipws >> a;
                                cache  <<  a;
                                size_t found=cache.str().find("fi MacaulayDefinitions");
                                if (found!=string::npos)
                                        macaulayCode=false;
                                continue;
                        }

                        stripComments(fileInStream_);
                        fileInStream_ >> std::ws;
                        stripComments(fileInStream_);
                        //if (fileStringStream.peek()=='L')
                        //      break;
                        paramname=readParamName(fileInStream_);
                        
                        cerr << "paramname" << "[" << paramname << "]"<<endl;
                        parameterNameExpected_m=false;
                        #ifdef DEBUG
                                cerr <<" loadParamList, paramname = " <<paramname << endl;
                        #endif
                        //fileStringStream >> std::ws;

                        extractChar('=',fileInStream_);
                        //fileStringStream >> std::ws;
                        string paramValue=readParamValue(fileInStream_, paramname);
                        #ifdef DEBUG
                                cerr <<" loadParamList, paramValue = " <<paramValue << endl;
                        #endif
                        //fileStringStream >> std::ws;
                        extractChar(';',fileInStream_);
                        //fileStringStream >> std::ws;
                        string comment=readCurrentComment(fileInStream_);
                        
                        if ( paramname.compare("LInputString")==0 )
                        {
                                continue;
                        }
                        if ( paramname.compare("cfEndParams")==0 )
                        {
                                break;
                        }
                        if ( paramname.compare("cfMacaulayCode")==0 )
                        {
                                cache.clear();
                                macaulayCode=true;
                                continue;
                        }

                        if (paramname.compare("L")==0)
                        {
                                paramname = "L_input";

                                paramname = "LInputString";
                                
                                paramValue = string("\" L =  ") + paramValue + string(";\"");
                                
                        }
                        
                        //std::cerr << "\t\t  (" << comment << ") " << std::endl;
                        //paramList_m->addParameter( paramname.c_str(), paramValue.c_str(), comment.c_str() );
                        paramList_m->addParameter( paramname, paramValue, comment );
                        
                        
                        parameterNameExpected_m=true;
                }
                Parameter & LInputString = paramList_m->getParameterRefByName("LInputString");
                LInputString.setPrintOrder(170);
                LInputString.markUsed();
        
        }
        
        std::cerr << "convertStringParamsToOptions" << std::endl << std::endl;
        convertStringParamsToOptions();
        std::cerr << "checkParameters" << std::endl << std::endl;
        checkParameters();
        std::cerr << "loadParams :finished!" << std::endl << std::endl;
}




template <class TPolynomXY, class TRing >
void CenterfocusParams< TPolynomXY, TRing >::printParameters(ostream &oFile) const
{

                oFile << std::endl << "cfMacaulayCode = \"\"; " << std::endl; 
                oFile << std::endl << " try ( if (not MacaulayDefinitions) then ()) then (MacaulayDefinitions=MacaulayDefinitions) else (MacaulayDefinitions=true);" << std::endl;

                oFile << std::endl << "if MacaulayDefinitions then {" << std::endl;
                oFile << "-- Macaulay2 defines: " << std::endl;
                oFile << "\tp = " << fieldCharacteristic_m << ";"<< std::endl;          
                oFile << "\t-- define field:" << std::endl;
                oFile << "\tFp = ZZ/p;" << std::endl;
                oFile << "\t-- define rings :" << std::endl;
                oFile << "\t-- for calculation with epsilon" << std::endl;
                oFile << "\tScf = Fp[eps]; " << std::endl;

        
                oFile << "\tTcf = Fp[ "   ;
        
                bool    firstEntry =true;
                int     ttIndex=1;

                list<CoeffListEntry>::const_iterator coeffIt;

                for ( coeffIt = coeffVariablesOrder_m.begin(); coeffIt!=coeffVariablesOrder_m.end(); coeffIt++, ttIndex++  )
                {
                        if (!firstEntry)
                                oFile << ", " ;
                        else
                                firstEntry = false;
                        oFile << "tt_"<< ttIndex ;      
                }

                oFile << " ];"  << std::endl;

                firstEntry = true;
                oFile << "\tPQcf = Fp[ ";

                for ( coeffIt = coeffVariablesOrder_m.begin(); coeffIt!=coeffVariablesOrder_m.end(); coeffIt++  )
                {
                        if (!firstEntry)
                                oFile << ", " ;
                        else
                                firstEntry = false;
                                
                        if ( (*coeffIt).isPMonom() )
                                oFile << "pp_{"<< (*coeffIt).x_exp << "," << (*coeffIt).y_exp << "}";
                        else
                                oFile << "qq_{"<< (*coeffIt).x_exp << "," << (*coeffIt).y_exp << "}";
                }

                oFile << " ];"  << std::endl;
                oFile  << "} --fi MacaulayDefinitions " << std::endl;
                paramList_m->printNotUsedParameters(oFile);

                paramList_m->printUsedParameters(oFile);

}

// muss vor der Initialisierung der Anzahl der Zufallsversuche stattfinden.
template <class TPolynomXY, class TRing >
void    CenterfocusParams< TPolynomXY, TRing >::initHasVariableCoefficients()
{

        bHasVariableCoefficients_m = false;

        positionInLValue_m=false;


        parameterNameExpected_m = true;
         
        inputFile_m->clear();
        assert(!inputFile_m->fail() );
        inputFile_m->seekg (0, ios::beg);
        assert(!inputFile_m->fail() );
        positionInLValue_m = false;
        firstPQ_m       = true;
        braceLevel_m    = 0;

        while( readNextPolynoms() )
        {
                if (polynomsContainsVariableCoeff() )
                {
                        bHasVariableCoefficients_m = true;
                        return;
                }
        }
        inputFile_m->clear();
        assert(!inputFile_m->fail());
        inputFile_m->seekg (0, ios::beg);
        assert(!inputFile_m->fail());
        positionInLValue_m=false;
        firstPQ_m       = true;
        braceLevel_m    = 0;

        positionInLValue_m      = false;
        parameterNameExpected_m = true;

        return ;
}

template <class TPolynomXY, class TRing >
 bool   CenterfocusParams< TPolynomXY, TRing >::areWellDefined()
{

        bool wellDefined=true;

        positionInLValue_m=false;

        int experimentCounter=0;

        bHasVariableCoefficients_m = false;

        parameterNameExpected_m = true;
        
        inputFile_m->clear();
        assert( !inputFile_m->fail() );
        inputFile_m->seekg (0, ios::beg);
        assert(!inputFile_m->fail());
        positionInLValue_m = false;
        firstPQ_m       = true;
        braceLevel_m    = 0;



        while( readNextPolynoms() )
        {
                assert(!inputFile_m->fail());
                if (polynomsContainsVariableCoeff() )
                {
                        bHasVariableCoefficients_m=true;
                }
                if (experimentCounter>0 &&  (polynomsContainsVariableCoeff() || bHasVariableCoefficients_m) )
                {
                        std::cerr << "Error: currently it is not allowed to define multiple random experiments in one input file \
                                        or to mix experiments with varyying coefficients with simple point tests " << std::endl;
                        wellDefined= false;
                }
                
                experimentCounter++;
        }
        inputFile_m->clear();
        assert(!inputFile_m->fail());
        inputFile_m->seekg (0, ios::beg);
        assert(!inputFile_m->fail());
        positionInLValue_m=false;
        firstPQ_m       = true;
        braceLevel_m    = 0;

        positionInLValue_m      = false;
        parameterNameExpected_m = true;

        assert(maxFocalValuesToCompute_m>0);
        assert(maxFocalValuesToCompute_m <=  getMaxComputableFocalValues() );

        assert(exhaustiveLiftTrials_m>=liftTrials_m);
        assert(exhaustiveMaxLift_m>=maxLift_m);

        if (getEpsPrecision()<0)
        {
                std::cerr << "Error: negative epsPrecision" <<std::endl;
                wellDefined= false;
        }
        
        if (benutzeFormel_2_m && benutzeFormel_23_m)
        {
                std::cerr << "Error: it is not possible to use together formula2 and formula23)" <<std::endl;
                wellDefined= false;
        }
        if (benutzeFormel_23_m && ! benutzeFormel_1_m)
        {
                std::cerr << "Error: it is not allowed to use formula23 without formula1."<< std::endl;
                wellDefined= false;
        }
        if (benutzeFormel_2_m && ! benutzeFormel_1_m)
        {
                std::cerr << "Error: it is not allowed to use formula2 without formula1."<< std::endl;
                wellDefined= false;
        }

        if ( benutzeFormel_23_m && this->polynomsHaveCheckAllCoeff() )
        {
         
                std::cerr << "Error: AllCoefficient-search is not implemented for formula23 )" <<std::endl;
                wellDefined= false;
        }

        if (!bHasVariableCoefficients_m && (benutzeFormel_1_m || benutzeFormel_2_m || benutzeFormel_23_m) )
        {       
                std::cerr << "Error: it is not possible to use a formula without random coefficients" <<std::endl;
                wellDefined= false;
        }

        if (!polynomsHaveRandomCoeff() && getRequestedTrialsNum()>0) 
        {
                std::cerr << "Error: it is not possible to perform random trials without random coefficients" <<std::endl;
                wellDefined= false;
        }


        assert(this->getRequestedLiftPointNum()>=0 );
        if (this->getRequestedLiftPointNum()>0 )
        {
                // wenn liftTrials=0 werden auch keine Versuche unternommen, LiftPunkte zu berechnen, wie soll das denn gehen?
                assert( liftTrials_m > 0 );
        }

        if ( liftTrials_m<0 || maxLift_m<0) 
        {
                std::cerr << "Error:liftTrials_m or maxLift_m<0 !"<< std::endl;
                //std::cerr << "Error: lift test must be performed. The smallest lift test is maxLift=2 and liftTrials=1 !"<< std::endl;
                wellDefined= false;

        }
        // Frage: wo gehört dieser Test hin, hierhin oder zur Klasse, welche den Lift-test durchführt?
        //assert( this->liftTrials_m>0 );
        if ( getMaxLift()>0 ) 
                assert( liftTrials_m>0 );

        if ( liftTrials_m>0 ) 
        {
         
                if (bReqVanishedFocalValues_m  <= 0)
                {
                        std::cerr << "Error: for a lift required vanished focal values must be at least 1 !"<< std::endl;
                        wellDefined= false;
                }

                if (getMaxLift() < 2)
                {
                        std::cerr << "Error: for a lift test maxLift must be at least =2 !"<< std::endl;
                        wellDefined= false;
                }
                #ifdef USESSE
                        // TODO: diese Abfrage muss noch verbessert werden.
                        assert(getMaxLift()< ringEps_m->maxEpsPrecision_m - 16);
                #endif

                if (getEpsPrecision()>0)
                {
                        std::cerr << "epsPrecision is > 0. TODO: what is a lift test for a point with epsPrecision>0?"<< std::endl;
                        wellDefined= false;
                }
        }
        assert(minComponentCodim_m>=0);

        assert(pointFilter);

        assert(requiredVanishedFocalValuesNum()>=getParametrizedFocalValuesNum() );

        assert( this->gradderpolynome_m>1 );

        // Hamilton-Filter nur fuer Grad 2 und 3 implementiert und wird immer verwendet.
        assert( this->gradderpolynome_m<=3 );
                
        //assert(this->requiredVanishedFocalValuesNum()>0);// das ist egal

        
        return wellDefined;
}



template <class TPolynomXY, class TRing >
void    CenterfocusParams< TPolynomXY, TRing >::initAllCoeffitientsAreVariables()
{
        std::list<CoeffListEntry>::const_iterator coeffIt;

        bAllConstCoefficientsAreVariables_m=true;

        coeffIt =coeffVariablesOrder_m.begin();
        while (coeffIt!=coeffVariablesOrder_m.end() )
        {
                if (!   isCoefficientVariable( *coeffIt ) )
                {
                        bAllConstCoefficientsAreVariables_m=false;
                        return;
                }
                coeffIt++;
        }
        
}
template <class TPolynomXY, class TRing >
void    CenterfocusParams< TPolynomXY, TRing >::initCoeffVariablesOrder( )
{
        for (int  currentMonomDegree=2; currentMonomDegree <= getPolynomialDegree(); currentMonomDegree++)
        {

                CoeffListEntry currentEntry;
                for (int j=0; j<=currentMonomDegree; j++ )
                {
                        currentEntry=CoeffListEntry(    PCoefficient,j,currentMonomDegree       );
                        coeffVariablesOrder_m.push_back( currentEntry   );
 
                }
                for (int j=0; j<=currentMonomDegree; j++ )
                {
                        currentEntry=CoeffListEntry(    QCoefficient,j,currentMonomDegree       );
                        coeffVariablesOrder_m.push_back(        currentEntry    );      
                }
        }
}

 
template <class TPolynomXY, class TRing >
long64  CenterfocusParams< TPolynomXY, TRing >::getCoeffTry(const CoeffList & coefflist ) const
{
        list<CoeffListEntry>::const_iterator coeffIt = coeffVariablesOrder_m.end();

        long64 coeffTry=0;

        do 
        {
                coeffIt--;
                coeffTry=coeffTry << 1;
                if (    coefflist.containsEntry(*coeffIt)       )
                {
                        (coeffTry = coeffTry | 1);
                }
                
        }
        while(coeffIt!=coeffVariablesOrder_m.begin() );

        return coeffTry;
}

template <class TPolynomXY, class TRing >
long64  CenterfocusParams< TPolynomXY, TRing >::getCoeffTryAll() const
{
        assert( getPolynomialDegree()<7 ) ;
        return getCoeffTry(monomsWithAllCoefficients_m);
}


template <class TPolynomXY, class TRing >
long64  CenterfocusParams< TPolynomXY, TRing >::getCoeffTryRandom() const
{
        assert( getPolynomialDegree()<7 ) ;
        return getCoeffTry(monomsWithRandomCoefficients_m);
}