centerfocus.cpp

Go to the documentation of this file.

 

#include "typedefs.h"
#include <unistd.h>
#include <time.h>
#include <signal.h>
        
#ifdef MTCP
        #include "mtcp.h"
#endif


#include "centerfocus_defines.h"





#include <iostream>
#include <fstream>

#include <stdlib.h>


#include <time.h>
#include <sstream>
#include <list>
#include <assert.h>
#include <iomanip>
#include <iostream>


#include "timer.h"

#include "PerformanceStatistics.h"

#include "Parameterlist.h"

#include "CoeffList.h"
#include "Statistik.h"
#include "RangStatistik.h"
#include "QuadricsStatistic.h"
#include "LiftStatistic.h"
#include "ReadCenterFocusParams.h"

#include "random.h"








using std::list;



#include "Output.h"
#include "Algorithm.h"


#define USEDHOSTNAMELEN 256

#ifdef CF_TEST
        #include "CenterFocusTestUnit.h"
        #include "Tests.h"
#endif
 #include <cxxtest/TestSuite.h>

/*
int getCurrentRevision()
{

}*/


void printProgramAndEnvironmentInfo(ostream &os,  const char* argv[])
{

        os << std::endl;
        os << "-- program information: " << std::endl;
        os << "-- program " << argv[0] << "; " << std::endl;
        os << "   programID = " << PROGRAMID << ";"<<std::endl;
        
        os << "--          svn: " << REVISION << std::endl;
        os << "--          compile flags: " << SW_STATUS(COMPILEFLAGS) << std::endl;
        cerr << "--          compile flags: " << SW_STATUS(COMPILEFLAGS) << std::endl;

        //os << "--           " << SVNROOT << std::endl;

        os << "cfSvnRoot = \""<<  SVNROOT << "\";" << std::endl;
        string containCfRevision(REVISION);
        std::string::size_type pos = containCfRevision.find_last_of(":");
        string cfRevision= containCfRevision.substr(pos+1);

        #ifdef SVN
        
        #endif
        os << "cfSvnRevision = \""<<  cfRevision << "\";" << std::endl;
        //os << "cfStatus = \" " << SW_STATUS(STATUS) << " \" ;" <<std::endl << std::endl;
        os << "cfStatus =  " << SW_STATUS(STATUS) << "  ;" <<std::endl << std::endl;
        
        char* hostname = new char[USEDHOSTNAMELEN];

        memset(hostname, '\0', USEDHOSTNAMELEN);

        int resGetHostname = gethostname(hostname, USEDHOSTNAMELEN - 1 );
        assert(resGetHostname==0);
        
        os << "--" << " started on host: ["  <<  hostname << "] " << std::endl;
        delete[] hostname;      
        os << "-- " << std::endl;

        string  strScalarType(SW_STATUS(defined_Scalar_Type));
        size_t  found = strScalarType.find("unsigned");

        if ( found != std::string::npos )
                std::cerr << "-- warning, defined_Scalar_Type is unsigned ! " << std::endl;
        os << "--          defined_Scalar_Type : " << SW_STATUS(defined_Scalar_Type) << std::endl;

        #ifdef OPTIMIZED_FIELD
                os << "--          max monom degree : " << SW_STATUS(MAXMONOMDEG) << std::endl;
                os << "--          FIELDCHAR : "        << SW_STATUS(FIELDCHAR) << std::endl;
        #endif

        os << "--          sizeof(size_t) "     << sizeof(size_t) << std::endl;
        os << "--          sizeof(char) "       << sizeof(char) << std::endl;   
        os << "--          sizeof(short) "      << sizeof(short) << std::endl; 
        os << "--          sizeof(int) "        << sizeof(int) << std::endl; 
        os << "--          sizeof(long) "       << sizeof(long) << std::endl; 
//      std::cout << "--          sizeof(enum) "        << sizeof(enum s { aaaa }) << std::endl; 
        

        #ifdef UNSIGNED
                os << "-- Warning: defined_Scalar_Type is unsigned" << std::endl;
        #endif

        #ifdef MAXMONOMDEG
                os << "-- maxmonomdegree: " << MAXMONOMDEG << std::endl;
        #endif


        #ifdef DEBUG
                std::cerr << "getchar" << std::endl;
                getchar();
        #endif
        
        std::cerr << "--------------" << std::endl << std::endl;
}


void printResultFormatInfo(ostream &os)
{
        os << "-- The result is formatted as follows: "  << endl;
os << "--  "  << endl;
os << "-- L =  { Level_0 } ; "  << endl;
os << "--  "  << endl;
os << "--   Level_0  := empty | Experiment_0,   Experiment_1, ... , Experiment_n }  "  << endl;
os << "--  "  << endl;
os << "--   Experiment_i  :=   { Point, PointID, VanishedValuesNum, FocalValuesList, } "  << endl;
os << "--                     | { Point, PointID, VanishedValuesNum, FocalValuesList, Jacobian, rank(Jacobian) } "  << endl;
os << "--                     | { Point, PointID, VanishedValuesNum, FocalValuesList, Jacobian, rank(Jacobian), QuadricSmall, TangentCone2 } "  << endl;
os << "--  "  << endl;
os << "--  with "  << endl;
os << "--  Point  :=            {       PMonomCoefficients_Degree_2, QMonomCoefficients_Degree_2, " << endl;
os << "                                 PMonomCoefficients_Degree_3, QMonomCoefficients_Degree_3,...," << endl;
os << "                                 PMonomCoefficients_Degree_N, QMonomCoefficients_DegreeN }"  << endl;
os << " where  Degree 'N'  is max( deg(P),deg(Q) ) "  << endl;
os << "--  and "  << endl;
os << "--  PMonomCoefficients_Degree_i := { coeff ( PMonom x^i*y^0  ), coeff ( PMonom x^(i-1)*y^1  )... , coeff ( PMonom x^0*y^i )  }" << endl;
os << "--  QMonomCoefficients_Degree_i := { coeff ( QMonom x^i*y^0  ), coeff ( QMonom x^(i-1)*y^1  )... , coeff ( QMonom x^0*y^i )  }" << endl;
os << " where  Degree N  is max( deg(P),deg(Q) ) "  << endl;
os << "--  "  << endl;
os << "--  with "  << endl;
os << "--  FocalValuesList  :=  {       focalvalue_01, focalvalue_02, ... , focalvalue_? }" << endl;
os << "--  (length of FocalValuesList is varying, minimum is = min( number of vanished focalvalues + 1, maxFocalValuesToCompute ) " << endl;
os << "--  "  << endl;
os << "--  with "  << endl;
os << "--  Jacobian  := {       MatrixRow_0, MatrixRow_1, MatrixRow_1, ... , MatrixRow_(S-1) }" << endl;
os << " where  row count S  is ='minNullen', ( requested number of vanished focal values) "  << endl;
os << " and MatrixRow_i := { MatrixEntry#i#0, MatrixEntry#i#1, ... ,  MatrixEntry#i#cols-1 } " << endl;
os << " where  'cols' is either the number of variated P,Q monom coefficients (parameter JacobiUnterMatrix = 1) "<< endl;
os << " or  'cols' is the number of all P,Q monom coefficients (  parameter JacobiUnterMatrix = 0) "<< endl;
os << "--  "  << endl;
os << "--  with "  << endl;
os << "--  QuadricSmall  :=     {       t^T*RB_0*t, t^T*RB_1*t, ..  t^T*RB_r * t }" << endl;
os << "--  where t      :=      {       t_1,...t_#b }" << endl;
os << "--  #b           :=      dim Ker (Jacobi)" << endl;
os << "--  and <RB_0,RB_1,..RB_r > = basis ( R_0,R_1,,..R_#c )" << endl;
os << "--  and r = dim<RB_0,RB_1,..RB_r > " << endl;
os << "--  #c is rank CoKer(Jacobian)" << endl;
os << "--   R_i' =  CoKer(Jacobian) * Lambda_i " << endl;
os << "--  and ( R_0,R_1,,..R_#c ) = transversalView (  R_0',R_1',,..R_#c' ) " << endl;
os << "--  where (  R_0',R_1',,..R_#c' ) is a 3D matrix " << endl;
os << "--  "  << endl;
os << "--  with "  << endl;
os << "--  TangentCone2 :=      {       LinearBig, QuadricBig } " << endl;
os << "--  LinearBig := {       varsPQ^T*Ker(Jacobian) } " << endl;
os << "--  QuadricBig :=        {       varsPQ^T*(D^T* RB_0 *D)* varsPQ, " << endl;
os << "--                                       varsPQ^T*(D^T* RB_1 *D)* varsPQ, ..., varsPQ^T*(D^T* RB_r *D)*varsPQ }" << endl;
os << "--  where  D = LeftInverse ( Ker(Jacobian) )  " << endl;
os << "--  and varsPQ = ? " << endl;
os << "--  "  << endl;

}


namespace nCenterFocus
{

// TS_ASSERT

template<class MatrixType, class VectorType1, class VectorType2>
void testSolveLGS(MatrixType &lgs, VectorType1 &rightHandSide, VectorType2 &referenceSol, int referenceRank, int solutionNum )
{

        typename MatrixType::ElementType * localRightHandSide = new typename MatrixType::ElementType[ lgs.getRowNum() ];

        for (int varNum=0; varNum<lgs.getRowNum() ; varNum++)
                localRightHandSide[varNum] = rightHandSide[varNum].getX();

        int rank=-1;
        typename MatrixType::ElementType *      LGSsol = lgs.solveLGS( localRightHandSide, rank );

        cerr << "LGS solved" << endl;
        if (solutionNum>0)
        {
        
                assert( LGSsol );
                //assert (referenceRank == rank );
                if (solutionNum==1)
                for (int varNum=0; varNum<lgs.getColNum() ; varNum++)
                {
                        assert( LGSsol[varNum] == referenceSol[varNum].getX() );
                        //cerr << "ffpackLGSsol["<<varNum <<"] " << ffpackLGSsol[varNum] << endl;       
                }
                assert (referenceRank == rank );
        }
        else
                assert(!LGSsol);
        delete[] localRightHandSide;
        return ;
}


void testSolveLGS(int characteristic, string &inputMatrixStr ,string &rhsString, string &referenceSolString, int referenceRank, int solutionNum)
{
        defined_Field_Type      field(characteristic,0);

        stringstream referenceSolStream (referenceSolString);
        
        stringstream rhsStream (rhsString);
        TVector<defined_Field_Type> referenceSol(&field, referenceSolStream );

        stringstream inputMatrixStream (inputMatrixStr);

        TMatrix<defined_Field_Type>     testMatrix( &field, inputMatrixStream, "testMatrix" );

        typedef FFpackMatrix< Modular<double> >  FFpackMatrixType;
        
        
        TVector<defined_Field_Type> rightHandSide(&field, rhsStream );
                
        FFpackMatrixType        lgs(testMatrix, characteristic);
        
        //lgs.printValue(cerr);

        testSolveLGS(lgs,rightHandSide,referenceSol, referenceRank, solutionNum)  ;
}

void lgsSandbox()
{
        int characteristic=23;
        int solutionNum;
        int referenceRank=-1;

//-------------------------------------------------------------
        string inputMatrixStr   ( " { {0 ,0, 0 }, {0, 0, 22 } }" );
        string rhsString                ( "  {0, 4   } " );
        string referenceSol     ( "  {0, 0, 19 } " );

        testSolveLGS(characteristic, inputMatrixStr, rhsString, referenceSol, referenceRank=1, solutionNum=1);


//-------------------------------------------------------------
         inputMatrixStr         = (     " { {0 ,0, 0 }, {0, 0, 23 } }" );
         rhsString              = (     "  {1, 4 } " );
         referenceSol   = (     "  {0, 0, 19 } " );

        testSolveLGS(characteristic, inputMatrixStr, rhsString, referenceSol,  referenceRank=-1, solutionNum=0);


//-------------------------------------------------------------
         inputMatrixStr =       ( " { {1 ,0 }, {0, 2 } }" );
         rhsString =    ( "  {1, 4 } " );
         referenceSol = ( "  {1, 2 } " );

        testSolveLGS(characteristic, inputMatrixStr, rhsString, referenceSol,  referenceRank=2, solutionNum=1);

//-------------------------------------------------------------
         inputMatrixStr =       ( " { {1 ,0 }, {0, 2 }, {0, 16 } }" );
         rhsString =    ( "  {1, 4, 9 } " );
         referenceSol = ( "  {1, 2 } " );

        testSolveLGS(characteristic, inputMatrixStr, rhsString, referenceSol, referenceRank=2, solutionNum=1);

        //-------------------------------------------------------------
         inputMatrixStr =       ( " { { 0 ,2 }, {1, 0 }, {0, 16 } }" );
         rhsString =    ( "  {4, 1, 9 } " );
         referenceSol = ( "  {1, 2 } " );

        testSolveLGS(characteristic, inputMatrixStr, rhsString, referenceSol,referenceRank=2, solutionNum=1);

        inputMatrixStr =        ( " { {0 ,22, 0 }, {0, 0, 22 } }" );
        rhsString       =       ( "  {4, 4   } " );
        referenceSol =  ( "  {0, 19, 19 } " );

        testSolveLGS(characteristic, inputMatrixStr, rhsString, referenceSol,referenceRank=2,  solutionNum = 1);

        inputMatrixStr =        ( " { { 8, 17,  5,  9, 13, 20,  0, 15,  0, 22,  1,  0,  8,  0}, {13,  5, 16,  4,  0, 16, 20, 17, 17, 20, 12,  2, 15, 21}, {13, 22, 13, 14,  5,  9, 16, 17, 11,  7, 21,  9,  6, 13} }" );
        rhsString       =       ( "  {15, 5, 13  } " );
        referenceSol =  ( "  { 8, 17,  5,  9, 13, 20,  0, 15,  0, 22,  1,  0,  8,  0} " );

        testSolveLGS(characteristic, inputMatrixStr, rhsString, referenceSol,referenceRank=3,  solutionNum = 2);


        cerr <<" lgsSandbox     Test passed!" << endl;
}


int centerfocus(int argc, const char* argv[]);
};
int main(int argc, const char* argv[])
{

        
        #ifdef COUNT
                // todo: schoener machen!
                initCounters();
        #endif

        #ifdef CF_TEST
                cerr << "CF_TEST defined" << endl;
                nCenterFocus::frommerTest();
                nCenterFocus::lgsSandbox();
                nCenterFocus::testAllPolynomDefs();
                testRandom(29);
            autotest();
        #endif
        //#ifndef TEST
                //      nCenterFocus::testExample();
                //nCenterFocus::autotest();             

                try {
        
                        return nCenterFocus::centerfocus(argc,argv);
                }
                catch(const char* error)
                {
                        //int* a=0;
                        //a[0]=0;
                        std::cerr << "Error:" << error << std::endl;
                }
                catch(char* error)
                {
                        //int* a=0;
                        //a[0]=0;
                        std::cerr << "Error:" << error << std::endl;
                }


//      #else
//              testRandom();
//              autotest();
//      #endif

        
}


 


namespace nCenterFocus
{


void correctVanishedFocalValuesStatistic(const D_CenterfocusParams & params, DStatistic& st)
{
        if (params.polynomsContainsVariableCoeff() )
        {
                int parametrizedFocalValuesNum=params.getParametrizedFocalValuesNum();
        
                assert(params.requiredVanishedFocalValuesNum()>=params.getParametrizedFocalValuesNum() );
        
                //long64 correctedVanishedFocalValuesCount = st.getTrialCountWithGivenNumOfFirstSuccessiveVanishedFocalValues(parametrizedFocalValuesNum+1);
        
                switch (params.getHamiltonianComponentSwitch() )
                {
                        case 1: 



                
                                
                                assert( st.getMaxLoggedSuccessiveVanishedFocalValues()>=parametrizedFocalValuesNum ); // anderenfalls kann nicht korrigiert werden - stimmt nicht...
        
                        
                                // wenn 
                                st.correctHamiltonComponentStatistic(  parametrizedFocalValuesNum, hamiltonianPointCount_g      );
        
                                break;
        
                        case -1: 





        
                                st.correctNonHamiltonComponentStatistic( parametrizedFocalValuesNum,  hamiltonianPointCount_g   );
                                break;
        
                        default:        
                                break;
                }
        }
}


int centerfocus(int argc, const char* argv[])
{
         #ifdef MTCP
        //      mtcp_init("gleichzubegin.mtcp", 4, 0);
        #endif
        std::cerr << "__FUNCTION__" << __FUNCTION__ << endl;
        std::cerr << "__PRETTY_FUNCTION__" << __PRETTY_FUNCTION__ << endl;
        //std::cerr << " __FUNCSIG__ " <<  __FUNCSIG__  << endl;
        
        //testParameterParser01();

        #ifdef TIMER
                Timer tim;
                Timer sum;
                MtcpManager_g.connectTimer(tim);
                MtcpManager_g.connectTimer(sum);

                tim.clear(); 
                tim.start();

        #endif

        D_CenterfocusParams* params= new D_CenterfocusParams(argc, argv);

        #ifdef MTCP
                long randomSeed= params->getRandomSeedRef();
                std::stringstream sstr;
                sstr << randomSeed;
                //std::string mtcpName= sstr.str()+".mtcp";
                std::string mtcpName= params->getOutputFileName()+".mtcp";
                
                mtcp_init(mtcpName.c_str(),params->getCheckpointInterval() , 0); // einmal in 3 Stunden sichern...
        #endif

        printProgramAndEnvironmentInfo(params->getOsRef(), argv);

        PrintCenterFocusResults    resultPrinter(params->getOsRef(), std::cerr );


        resultPrinter.printHeader( *params  );

        #ifdef MTCP
                MtcpManager_g.checkpointingTimeFrame();
        #endif

        //printHeader(os, params->params,argv, params->inputFromStd);

        
        int maxJacobianRank = min( params->getPDFCoefficientNum(), params->getMaxFocalValuesToCompute() );

        RankStatistic           fullRankStatistic(      RankStatistic::fullRankStatisticString,
                                                                        params->requiredVanishedFocalValuesNum(),
                                                                        params->getMaxFocalValuesToCompute(), 
                                                                        maxJacobianRank );

        RankStatistic           subRankStatistic(       RankStatistic::subRankStatisticString  ,        
                                                                params->requiredVanishedFocalValuesNum(),  
                                                                params->getMaxFocalValuesToCompute(),
                                                                maxJacobianRank );

        LiftAndQuadricsStatistic        fullQuadricsStatistic(  "fullQuadricsStatistic", 
                                                        params->requiredVanishedFocalValuesNum(),
                                                        params->getMaxFocalValuesToCompute(),
                                                        maxJacobianRank ,
                                                        params->getExhaustiveMaxLift() ,
                                                        params->getExhaustiveLiftTrials()
                                                        );
        LiftAndQuadricsStatistic        subQuadricsStatistic(   "subQuadricsStatistic"  ,
                                                        params->requiredVanishedFocalValuesNum(), 
                                                        params->getMaxFocalValuesToCompute(),
                                                        maxJacobianRank ,
                                                        params->getExhaustiveMaxLift() ,
                                                        params->getExhaustiveLiftTrials()
                                                );

        FailedLiftStatistic liftStatistic(params->getExhaustiveMaxLift(), params->getExhaustiveLiftTrials() ) ;
        

        CenterFocusExperiment<1>        cfExperiment(params, &resultPrinter); // wozu params hier uebergeben, und wozu variant?
        #ifdef VALGRIND
                std::cerr << "getchar in centerfocus " << std::endl;
                getchar();
        #endif 

        std::cerr << "starting experiments..\n\n.\n\n " << std::endl;
        params->getOsRef() << "--Results " << std::endl;
        params->getOsRef() << "cfBeginResults = \"\";  -- begin results marker" << std::endl;

        resultPrinter.startPrintingResults( );
         
        int experimentCounter=0;

        long64 inputPointCounter=0;

        assert( params->areWellDefined() );

        
        //os_m << std::endl << "--Results: " << std::endl;
        while (params->readNextPolynoms() )
        { 
                // ist ineffektiv, da nur beim Zufallsversuch notwendig, aber egal.
                //if ( hasVariableCoefficients() )
                //      initAllCoeffitientsAreVariables();
                #ifdef DEBUG
                        std::cerr <<std::endl << "readNextPolynoms : " << " ! \n" ;
                        getchar();
                #endif
                //starte ein Experiment. hässlich ist noch die Ausgabe - weil sie hier und in performExperiment geschieht...

                cfExperiment.performExperiment(params, fullRankStatistic, subRankStatistic, fullQuadricsStatistic, subQuadricsStatistic, liftStatistic);

                // Berechnungen abgeschlossen!          
                inputPointCounter+=cfExperiment.getInputPointNum();


                experimentCounter++;

        }
        


        //schauen wir einfach mal ob das geht:
        params->initAllCoeffitientsAreVariables();

         
        resultPrinter.endPrintingResults();
        params->getOsRef() << "cfEndParams = \"\"; -- end params marker" << std::endl;

        DStatistic& st = cfExperiment.getStatisticRef();

        if (    !params->polynomsHaveCheckAllCoeff() &&
                !params->polynomsHaveRandomCoeff()
        )
        {
                //params->getOsRef() << "inputPointCount = "     << inputPointCounter << ";" << std::endl;
                params->getOsRef() << "virtualInputPointCount = " << inputPointCounter << ";" << std::endl;
        }
        else
        {
                long64 experimentCounter= st.getTrialCountWithGivenNumOfFirstSuccessiveVanishedFocalValues(0);
        
                if (params->getParametrizedFocalValuesNum()==0) 
                {
                        assert(inputPointCounter>=experimentCounter);
                        experimentCounter = inputPointCounter;
                }
                params->getOsRef() << "virtualInputPointCount = " << experimentCounter << ";" << std::endl;
        }

        correctVanishedFocalValuesStatistic(*params, st);

        st.print(params->getOsRef());                           //  basic statistic output

        fullRankStatistic.print( params->getOsRef() );  //  print jacobi rank statistic for this experiment
        subRankStatistic.print( params->getOsRef()  );  //  print jacobi rank statistic for this experiment
        fullQuadricsStatistic.print( params->getOsRef() );      //  print jacobi rank statistic for this experiment
        subQuadricsStatistic.print(  params->getOsRef()  );     //  print jacobi rank statistic for this experiment

        
        params->getOsRef() << "hamiltonianCount =" << hamiltonianPointCount_g << ";"<<  std::endl;


        params->getOsRef() << "--endResults " << std::endl;
        params->getOsRef() << "cfEndResults = \"\"; -- end results marker" << std::endl;
        

        params->getOsRef() << std::endl ;

        cfExperiment.printVariableOrder(params->getOsRef() );

        


        //Pfusch:
        if (params->pureSmoothnessTest() )
                resultPrinter.printSmoothnessTestTail( params->getOsRef() );
        else
                resultPrinter.printTail( params->getOsRef() );

        params->getOsRef() << std::endl ;
        
        if (params->hasVariableCoefficients())
        {
                // die Bedeutung der beiden folgenden Parameter ist z.Zt gleichwertig
                // zukünftig wird unterschieden, ob der Konstante Term des Polynomkoeffizienten variiert wird, oder ein Eps-Anteil.
                params->getOsRef() << "hasVariableCoefficients = true;" << std::endl;
                params->getOsRef() << "hasVariableConstCoefficients = true;" << std::endl;
        }
        else
        {
                // die Bedeutung der beiden folgenden Parameter ist z.Zt gleichwertig
                // zukünftig wird unterschieden, ob der Konstante Term des Polynomkoeffizienten variiert wird, oder ein Eps-Anteil.
                params->getOsRef() << "hasVariableCoefficients = false;" << std::endl;
                params->getOsRef() << "hasVariableConstCoefficients = false;" << std::endl;
        }
        params->getOsRef() << "inputPointCounter = " << inputPointCounter << ";" << std::endl;

        // folgende Idee: wenn man nichst (im Rahmen der Variablen coeffTryRandom, coeffTryAll )über die PD-Koeffizienten sagen kann, trage NULL ein.
        // Falls es kein Zufallsexperiment war, trageje 0 ein.

        if (params->hasVariableCoefficients()  )
        {
                params->getOsRef() << "coeffTryRandom = " << params->getCoeffTryRandom() << ";" << std::endl;
                params->getOsRef() << "coeffTryAll = " << params->getCoeffTryAll() << ";" << std::endl;

                if (params->allConstCoefficientsAreVariables()  )
                {
                        params->getOsRef() << "allConstCoefficientsAreVariables = true;" << std::endl;
                }
                else
                {
                        // erstmal den Fall, dass nicht alle Koeffizienten zufällig sind, verbieten wenn eine der Formeln eingesetzt wird.
                        // Kann eventuell doch noch abgeschwächt werden, man sollte aber darauf achten,dass die Statistik noch korrekt bleibt!
                        //alle Koeffizienten, welche auf die Koeffizienten zur Parametrisierung der Strudelgroeßen einfluß haben, müssen zufällig sein.
                        assert(params->getParametrizedFocalValuesNum()==0);
                        params->getOsRef() << "allConstCoefficientsAreVariables = false;" << std::endl;
                }
        }
        else if (!params->hasVariableCoefficients()  && params->getRequestedTrialsNum()>0 )
        {
                assert(false); // kann eh nie eintreten, oder?
                params->getOsRef() << "allConstCoefficientsAreVariables = false;" << std::endl;
                params->getOsRef() << "coeffTryRandom = NULL ;"  << std::endl;
                params->getOsRef() << "coeffTryAll = NULL    ;" << std::endl;
        }
        else if (!params->hasVariableCoefficients()  && params->getRequestedTrialsNum()==0)
        {
                params->getOsRef() << "allConstCoefficientsAreVariables = false;" << std::endl;
                params->getOsRef() << "coeffTryRandom = 0 ;"  << std::endl;
                params->getOsRef() << "coeffTryAll = 0    ;" << std::endl;
        }
        params->getOsRef() << std::endl ;
        //params->getOsRef() << "-- centerfocus regular exit! \n" ;
        params->getOsRef() << "cfSuccess = true ; \n" ;

        cfExperiment.printAlgorithmTimings ( params->getOsRef() );      
        cfExperiment.printStageTimings ( params->getOsRef() );



        if (params->logExtendedLiftStatistic() )
        {
                liftStatistic.print(  params->getOsRef()  );
                g_extLiftStatistic.print(params->getOsRef() );
        }

        #ifdef TIMER
                tim.stop();
                resultPrinter.outputTimerInfo(params->getOsRef(),tim);
                resultPrinter.outputTimerInfo(std::cerr,tim);
                //cfExperiment.printTimins(params->getOsRef());
                //cfExperiment.printTimins(std::cerr);
        #endif
        
        fflush(stdin);

        assert(!params->getOsRef().fail() );


//      printResultFormatInfo( params->getOsRef() );

        params->getOsRef().close();
        
        if (! (params->writeResultToCout()) )
        {
                // TODO: dies geht nur, wenn nicht nach ostream ausgegeben wird.
                assert(!params->getOsRef().fail() );
        }
        
        
        #ifdef COUNT
                resultPrinter.outputOperationsCount(params->getOsRef());
                resultPrinter.outputOperationsCount(std::cerr);
        #endif
        std::cerr <<std::endl << "output file was " << params->getOutputFileName() << " ! \n" ;
        delete params;
        std::cerr <<std::endl << "-- centerfocus: successful!" << std::endl;

        #ifdef TIMER
                MtcpManager_g.disconnectTimer(tim);
                MtcpManager_g.disconnectTimer(sum);
        #endif

        return 0;
}







class CenterFocusOptions
{
        int     fieldCharacteristic;
        int     NumberOfFocalValuesToCompute;
        int     logExamlesWithMinJacobianRank;
        int     logExamlesWithMinVanishedFocalValues;
        bool    computeJacobianRank;
        long64  randomExperimentsNum;
        int     maxMonomDegreeInPorQ; //should be optional
        int     epsPrecision; 
        int     randomSeed;
        int     defaultRandomSeed;
        bool    abortFocalComputationOnFirstUnvanishedValue;//rechneBisMaxStrudel       = false;        -- 'false': abort focal values computation of a example if a value does not vanish; 'true': compute all 'maxStrudel' focal values
        bool    useFormula_1; //if true,  compute q(3,0) in a kind that first focal value vanish
        bool    useFormula_2; //if true,  compute p(3,0) in a kind that second focal value vanish
        bool    filderHamiltonComponents; // if true: don't filter Hamilton components
        bool    useTimerAsRandomSeed; //if false: use inital seed for random function given in 'zufallInit'; true: use timer as initial seed
        bool    jacobianSubMatrix; // default: false;   
        bool    progressIndication;
        long64  trialsForSingleProgressStep;

        ifstream        MonomialExperimentData;// ExperimentData as ifstream.
        CenterFocusOptions() {};
};


};